// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: protobuf/pg_query.proto
// Protobuf C++ Version: 4.25.1

#ifndef GOOGLE_PROTOBUF_INCLUDED_protobuf_2fpg_5fquery_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_protobuf_2fpg_5fquery_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION < 4025000
#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  // PROTOBUF_VERSION

#if 4025001 < 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  // PROTOBUF_MIN_PROTOC_VERSION
#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_bases.h"
#include "google/protobuf/generated_message_tctable_decl.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)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_protobuf_2fpg_5fquery_2eproto

namespace google {
namespace protobuf {
namespace internal {
class AnyMetadata;
}  // namespace internal
}  // namespace protobuf
}  // namespace google

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

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<::int32_t>::min(),
  OverridingKind_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool OverridingKind_IsValid(int value);
extern const uint32_t OverridingKind_internal_data_[];
constexpr OverridingKind OverridingKind_MIN = static_cast<OverridingKind>(0);
constexpr OverridingKind OverridingKind_MAX = static_cast<OverridingKind>(3);
constexpr int OverridingKind_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
OverridingKind_descriptor();
template <typename T>
const std::string& OverridingKind_Name(T value) {
  static_assert(std::is_same<T, OverridingKind>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to OverridingKind_Name().");
  return OverridingKind_Name(static_cast<OverridingKind>(value));
}
template <>
inline const std::string& OverridingKind_Name(OverridingKind value) {
  return ::google::protobuf::internal::NameOfDenseEnum<OverridingKind_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool OverridingKind_Parse(absl::string_view name, OverridingKind* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  QuerySource_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool QuerySource_IsValid(int value);
extern const uint32_t QuerySource_internal_data_[];
constexpr QuerySource QuerySource_MIN = static_cast<QuerySource>(0);
constexpr QuerySource QuerySource_MAX = static_cast<QuerySource>(5);
constexpr int QuerySource_ARRAYSIZE = 5 + 1;
const ::google::protobuf::EnumDescriptor*
QuerySource_descriptor();
template <typename T>
const std::string& QuerySource_Name(T value) {
  static_assert(std::is_same<T, QuerySource>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to QuerySource_Name().");
  return QuerySource_Name(static_cast<QuerySource>(value));
}
template <>
inline const std::string& QuerySource_Name(QuerySource value) {
  return ::google::protobuf::internal::NameOfDenseEnum<QuerySource_descriptor,
                                                 0, 5>(
      static_cast<int>(value));
}
inline bool QuerySource_Parse(absl::string_view name, QuerySource* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  SortByDir_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool SortByDir_IsValid(int value);
extern const uint32_t SortByDir_internal_data_[];
constexpr SortByDir SortByDir_MIN = static_cast<SortByDir>(0);
constexpr SortByDir SortByDir_MAX = static_cast<SortByDir>(4);
constexpr int SortByDir_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
SortByDir_descriptor();
template <typename T>
const std::string& SortByDir_Name(T value) {
  static_assert(std::is_same<T, SortByDir>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to SortByDir_Name().");
  return SortByDir_Name(static_cast<SortByDir>(value));
}
template <>
inline const std::string& SortByDir_Name(SortByDir value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SortByDir_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool SortByDir_Parse(absl::string_view name, SortByDir* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  SortByNulls_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool SortByNulls_IsValid(int value);
extern const uint32_t SortByNulls_internal_data_[];
constexpr SortByNulls SortByNulls_MIN = static_cast<SortByNulls>(0);
constexpr SortByNulls SortByNulls_MAX = static_cast<SortByNulls>(3);
constexpr int SortByNulls_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
SortByNulls_descriptor();
template <typename T>
const std::string& SortByNulls_Name(T value) {
  static_assert(std::is_same<T, SortByNulls>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to SortByNulls_Name().");
  return SortByNulls_Name(static_cast<SortByNulls>(value));
}
template <>
inline const std::string& SortByNulls_Name(SortByNulls value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SortByNulls_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool SortByNulls_Parse(absl::string_view name, SortByNulls* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SortByNulls>(
      SortByNulls_descriptor(), name, value);
}
enum SetQuantifier : int {
  SET_QUANTIFIER_UNDEFINED = 0,
  SET_QUANTIFIER_DEFAULT = 1,
  SET_QUANTIFIER_ALL = 2,
  SET_QUANTIFIER_DISTINCT = 3,
  SetQuantifier_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  SetQuantifier_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool SetQuantifier_IsValid(int value);
extern const uint32_t SetQuantifier_internal_data_[];
constexpr SetQuantifier SetQuantifier_MIN = static_cast<SetQuantifier>(0);
constexpr SetQuantifier SetQuantifier_MAX = static_cast<SetQuantifier>(3);
constexpr int SetQuantifier_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
SetQuantifier_descriptor();
template <typename T>
const std::string& SetQuantifier_Name(T value) {
  static_assert(std::is_same<T, SetQuantifier>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to SetQuantifier_Name().");
  return SetQuantifier_Name(static_cast<SetQuantifier>(value));
}
template <>
inline const std::string& SetQuantifier_Name(SetQuantifier value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SetQuantifier_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool SetQuantifier_Parse(absl::string_view name, SetQuantifier* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SetQuantifier>(
      SetQuantifier_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_IN = 7,
  AEXPR_LIKE = 8,
  AEXPR_ILIKE = 9,
  AEXPR_SIMILAR = 10,
  AEXPR_BETWEEN = 11,
  AEXPR_NOT_BETWEEN = 12,
  AEXPR_BETWEEN_SYM = 13,
  AEXPR_NOT_BETWEEN_SYM = 14,
  A_Expr_Kind_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  A_Expr_Kind_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool A_Expr_Kind_IsValid(int value);
extern const uint32_t A_Expr_Kind_internal_data_[];
constexpr A_Expr_Kind A_Expr_Kind_MIN = static_cast<A_Expr_Kind>(0);
constexpr A_Expr_Kind A_Expr_Kind_MAX = static_cast<A_Expr_Kind>(14);
constexpr int A_Expr_Kind_ARRAYSIZE = 14 + 1;
const ::google::protobuf::EnumDescriptor*
A_Expr_Kind_descriptor();
template <typename T>
const std::string& A_Expr_Kind_Name(T value) {
  static_assert(std::is_same<T, A_Expr_Kind>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to A_Expr_Kind_Name().");
  return A_Expr_Kind_Name(static_cast<A_Expr_Kind>(value));
}
template <>
inline const std::string& A_Expr_Kind_Name(A_Expr_Kind value) {
  return ::google::protobuf::internal::NameOfDenseEnum<A_Expr_Kind_descriptor,
                                                 0, 14>(
      static_cast<int>(value));
}
inline bool A_Expr_Kind_Parse(absl::string_view name, A_Expr_Kind* value) {
  return ::google::protobuf::internal::ParseNamedEnum<A_Expr_Kind>(
      A_Expr_Kind_descriptor(), name, value);
}
enum RoleSpecType : int {
  ROLE_SPEC_TYPE_UNDEFINED = 0,
  ROLESPEC_CSTRING = 1,
  ROLESPEC_CURRENT_ROLE = 2,
  ROLESPEC_CURRENT_USER = 3,
  ROLESPEC_SESSION_USER = 4,
  ROLESPEC_PUBLIC = 5,
  RoleSpecType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  RoleSpecType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool RoleSpecType_IsValid(int value);
extern const uint32_t RoleSpecType_internal_data_[];
constexpr RoleSpecType RoleSpecType_MIN = static_cast<RoleSpecType>(0);
constexpr RoleSpecType RoleSpecType_MAX = static_cast<RoleSpecType>(5);
constexpr int RoleSpecType_ARRAYSIZE = 5 + 1;
const ::google::protobuf::EnumDescriptor*
RoleSpecType_descriptor();
template <typename T>
const std::string& RoleSpecType_Name(T value) {
  static_assert(std::is_same<T, RoleSpecType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to RoleSpecType_Name().");
  return RoleSpecType_Name(static_cast<RoleSpecType>(value));
}
template <>
inline const std::string& RoleSpecType_Name(RoleSpecType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<RoleSpecType_descriptor,
                                                 0, 5>(
      static_cast<int>(value));
}
inline bool RoleSpecType_Parse(absl::string_view name, RoleSpecType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RoleSpecType>(
      RoleSpecType_descriptor(), name, value);
}
enum TableLikeOption : int {
  TABLE_LIKE_OPTION_UNDEFINED = 0,
  CREATE_TABLE_LIKE_COMMENTS = 1,
  CREATE_TABLE_LIKE_COMPRESSION = 2,
  CREATE_TABLE_LIKE_CONSTRAINTS = 3,
  CREATE_TABLE_LIKE_DEFAULTS = 4,
  CREATE_TABLE_LIKE_GENERATED = 5,
  CREATE_TABLE_LIKE_IDENTITY = 6,
  CREATE_TABLE_LIKE_INDEXES = 7,
  CREATE_TABLE_LIKE_STATISTICS = 8,
  CREATE_TABLE_LIKE_STORAGE = 9,
  CREATE_TABLE_LIKE_ALL = 10,
  TableLikeOption_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  TableLikeOption_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool TableLikeOption_IsValid(int value);
extern const uint32_t TableLikeOption_internal_data_[];
constexpr TableLikeOption TableLikeOption_MIN = static_cast<TableLikeOption>(0);
constexpr TableLikeOption TableLikeOption_MAX = static_cast<TableLikeOption>(10);
constexpr int TableLikeOption_ARRAYSIZE = 10 + 1;
const ::google::protobuf::EnumDescriptor*
TableLikeOption_descriptor();
template <typename T>
const std::string& TableLikeOption_Name(T value) {
  static_assert(std::is_same<T, TableLikeOption>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to TableLikeOption_Name().");
  return TableLikeOption_Name(static_cast<TableLikeOption>(value));
}
template <>
inline const std::string& TableLikeOption_Name(TableLikeOption value) {
  return ::google::protobuf::internal::NameOfDenseEnum<TableLikeOption_descriptor,
                                                 0, 10>(
      static_cast<int>(value));
}
inline bool TableLikeOption_Parse(absl::string_view name, TableLikeOption* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  DefElemAction_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool DefElemAction_IsValid(int value);
extern const uint32_t DefElemAction_internal_data_[];
constexpr DefElemAction DefElemAction_MIN = static_cast<DefElemAction>(0);
constexpr DefElemAction DefElemAction_MAX = static_cast<DefElemAction>(4);
constexpr int DefElemAction_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
DefElemAction_descriptor();
template <typename T>
const std::string& DefElemAction_Name(T value) {
  static_assert(std::is_same<T, DefElemAction>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to DefElemAction_Name().");
  return DefElemAction_Name(static_cast<DefElemAction>(value));
}
template <>
inline const std::string& DefElemAction_Name(DefElemAction value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DefElemAction_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool DefElemAction_Parse(absl::string_view name, DefElemAction* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DefElemAction>(
      DefElemAction_descriptor(), name, value);
}
enum PartitionStrategy : int {
  PARTITION_STRATEGY_UNDEFINED = 0,
  PARTITION_STRATEGY_LIST = 1,
  PARTITION_STRATEGY_RANGE = 2,
  PARTITION_STRATEGY_HASH = 3,
  PartitionStrategy_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  PartitionStrategy_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool PartitionStrategy_IsValid(int value);
extern const uint32_t PartitionStrategy_internal_data_[];
constexpr PartitionStrategy PartitionStrategy_MIN = static_cast<PartitionStrategy>(0);
constexpr PartitionStrategy PartitionStrategy_MAX = static_cast<PartitionStrategy>(3);
constexpr int PartitionStrategy_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
PartitionStrategy_descriptor();
template <typename T>
const std::string& PartitionStrategy_Name(T value) {
  static_assert(std::is_same<T, PartitionStrategy>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to PartitionStrategy_Name().");
  return PartitionStrategy_Name(static_cast<PartitionStrategy>(value));
}
template <>
inline const std::string& PartitionStrategy_Name(PartitionStrategy value) {
  return ::google::protobuf::internal::NameOfDenseEnum<PartitionStrategy_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool PartitionStrategy_Parse(absl::string_view name, PartitionStrategy* value) {
  return ::google::protobuf::internal::ParseNamedEnum<PartitionStrategy>(
      PartitionStrategy_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<::int32_t>::min(),
  PartitionRangeDatumKind_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool PartitionRangeDatumKind_IsValid(int value);
extern const uint32_t PartitionRangeDatumKind_internal_data_[];
constexpr PartitionRangeDatumKind PartitionRangeDatumKind_MIN = static_cast<PartitionRangeDatumKind>(0);
constexpr PartitionRangeDatumKind PartitionRangeDatumKind_MAX = static_cast<PartitionRangeDatumKind>(3);
constexpr int PartitionRangeDatumKind_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
PartitionRangeDatumKind_descriptor();
template <typename T>
const std::string& PartitionRangeDatumKind_Name(T value) {
  static_assert(std::is_same<T, PartitionRangeDatumKind>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to PartitionRangeDatumKind_Name().");
  return PartitionRangeDatumKind_Name(static_cast<PartitionRangeDatumKind>(value));
}
template <>
inline const std::string& PartitionRangeDatumKind_Name(PartitionRangeDatumKind value) {
  return ::google::protobuf::internal::NameOfDenseEnum<PartitionRangeDatumKind_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool PartitionRangeDatumKind_Parse(absl::string_view name, PartitionRangeDatumKind* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  RTEKind_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool RTEKind_IsValid(int value);
extern const uint32_t RTEKind_internal_data_[];
constexpr RTEKind RTEKind_MIN = static_cast<RTEKind>(0);
constexpr RTEKind RTEKind_MAX = static_cast<RTEKind>(9);
constexpr int RTEKind_ARRAYSIZE = 9 + 1;
const ::google::protobuf::EnumDescriptor*
RTEKind_descriptor();
template <typename T>
const std::string& RTEKind_Name(T value) {
  static_assert(std::is_same<T, RTEKind>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to RTEKind_Name().");
  return RTEKind_Name(static_cast<RTEKind>(value));
}
template <>
inline const std::string& RTEKind_Name(RTEKind value) {
  return ::google::protobuf::internal::NameOfDenseEnum<RTEKind_descriptor,
                                                 0, 9>(
      static_cast<int>(value));
}
inline bool RTEKind_Parse(absl::string_view name, RTEKind* value) {
  return ::google::protobuf::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,
  WCO_RLS_MERGE_UPDATE_CHECK = 5,
  WCO_RLS_MERGE_DELETE_CHECK = 6,
  WCOKind_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  WCOKind_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool WCOKind_IsValid(int value);
extern const uint32_t WCOKind_internal_data_[];
constexpr WCOKind WCOKind_MIN = static_cast<WCOKind>(0);
constexpr WCOKind WCOKind_MAX = static_cast<WCOKind>(6);
constexpr int WCOKind_ARRAYSIZE = 6 + 1;
const ::google::protobuf::EnumDescriptor*
WCOKind_descriptor();
template <typename T>
const std::string& WCOKind_Name(T value) {
  static_assert(std::is_same<T, WCOKind>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to WCOKind_Name().");
  return WCOKind_Name(static_cast<WCOKind>(value));
}
template <>
inline const std::string& WCOKind_Name(WCOKind value) {
  return ::google::protobuf::internal::NameOfDenseEnum<WCOKind_descriptor,
                                                 0, 6>(
      static_cast<int>(value));
}
inline bool WCOKind_Parse(absl::string_view name, WCOKind* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  GroupingSetKind_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool GroupingSetKind_IsValid(int value);
extern const uint32_t GroupingSetKind_internal_data_[];
constexpr GroupingSetKind GroupingSetKind_MIN = static_cast<GroupingSetKind>(0);
constexpr GroupingSetKind GroupingSetKind_MAX = static_cast<GroupingSetKind>(5);
constexpr int GroupingSetKind_ARRAYSIZE = 5 + 1;
const ::google::protobuf::EnumDescriptor*
GroupingSetKind_descriptor();
template <typename T>
const std::string& GroupingSetKind_Name(T value) {
  static_assert(std::is_same<T, GroupingSetKind>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to GroupingSetKind_Name().");
  return GroupingSetKind_Name(static_cast<GroupingSetKind>(value));
}
template <>
inline const std::string& GroupingSetKind_Name(GroupingSetKind value) {
  return ::google::protobuf::internal::NameOfDenseEnum<GroupingSetKind_descriptor,
                                                 0, 5>(
      static_cast<int>(value));
}
inline bool GroupingSetKind_Parse(absl::string_view name, GroupingSetKind* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  CTEMaterialize_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool CTEMaterialize_IsValid(int value);
extern const uint32_t CTEMaterialize_internal_data_[];
constexpr CTEMaterialize CTEMaterialize_MIN = static_cast<CTEMaterialize>(0);
constexpr CTEMaterialize CTEMaterialize_MAX = static_cast<CTEMaterialize>(3);
constexpr int CTEMaterialize_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
CTEMaterialize_descriptor();
template <typename T>
const std::string& CTEMaterialize_Name(T value) {
  static_assert(std::is_same<T, CTEMaterialize>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to CTEMaterialize_Name().");
  return CTEMaterialize_Name(static_cast<CTEMaterialize>(value));
}
template <>
inline const std::string& CTEMaterialize_Name(CTEMaterialize value) {
  return ::google::protobuf::internal::NameOfDenseEnum<CTEMaterialize_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool CTEMaterialize_Parse(absl::string_view name, CTEMaterialize* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  SetOperation_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool SetOperation_IsValid(int value);
extern const uint32_t SetOperation_internal_data_[];
constexpr SetOperation SetOperation_MIN = static_cast<SetOperation>(0);
constexpr SetOperation SetOperation_MAX = static_cast<SetOperation>(4);
constexpr int SetOperation_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
SetOperation_descriptor();
template <typename T>
const std::string& SetOperation_Name(T value) {
  static_assert(std::is_same<T, SetOperation>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to SetOperation_Name().");
  return SetOperation_Name(static_cast<SetOperation>(value));
}
template <>
inline const std::string& SetOperation_Name(SetOperation value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SetOperation_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool SetOperation_Parse(absl::string_view name, SetOperation* value) {
  return ::google::protobuf::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_PARAMETER_ACL = 28,
  OBJECT_POLICY = 29,
  OBJECT_PROCEDURE = 30,
  OBJECT_PUBLICATION = 31,
  OBJECT_PUBLICATION_NAMESPACE = 32,
  OBJECT_PUBLICATION_REL = 33,
  OBJECT_ROLE = 34,
  OBJECT_ROUTINE = 35,
  OBJECT_RULE = 36,
  OBJECT_SCHEMA = 37,
  OBJECT_SEQUENCE = 38,
  OBJECT_SUBSCRIPTION = 39,
  OBJECT_STATISTIC_EXT = 40,
  OBJECT_TABCONSTRAINT = 41,
  OBJECT_TABLE = 42,
  OBJECT_TABLESPACE = 43,
  OBJECT_TRANSFORM = 44,
  OBJECT_TRIGGER = 45,
  OBJECT_TSCONFIGURATION = 46,
  OBJECT_TSDICTIONARY = 47,
  OBJECT_TSPARSER = 48,
  OBJECT_TSTEMPLATE = 49,
  OBJECT_TYPE = 50,
  OBJECT_USER_MAPPING = 51,
  OBJECT_VIEW = 52,
  ObjectType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  ObjectType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool ObjectType_IsValid(int value);
extern const uint32_t ObjectType_internal_data_[];
constexpr ObjectType ObjectType_MIN = static_cast<ObjectType>(0);
constexpr ObjectType ObjectType_MAX = static_cast<ObjectType>(52);
constexpr int ObjectType_ARRAYSIZE = 52 + 1;
const ::google::protobuf::EnumDescriptor*
ObjectType_descriptor();
template <typename T>
const std::string& ObjectType_Name(T value) {
  static_assert(std::is_same<T, ObjectType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to ObjectType_Name().");
  return ObjectType_Name(static_cast<ObjectType>(value));
}
template <>
inline const std::string& ObjectType_Name(ObjectType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<ObjectType_descriptor,
                                                 0, 52>(
      static_cast<int>(value));
}
inline bool ObjectType_Parse(absl::string_view name, ObjectType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  DropBehavior_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

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

bool AlterTableType_IsValid(int value);
extern const uint32_t AlterTableType_internal_data_[];
constexpr AlterTableType AlterTableType_MIN = static_cast<AlterTableType>(0);
constexpr AlterTableType AlterTableType_MAX = static_cast<AlterTableType>(66);
constexpr int AlterTableType_ARRAYSIZE = 66 + 1;
const ::google::protobuf::EnumDescriptor*
AlterTableType_descriptor();
template <typename T>
const std::string& AlterTableType_Name(T value) {
  static_assert(std::is_same<T, AlterTableType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to AlterTableType_Name().");
  return AlterTableType_Name(static_cast<AlterTableType>(value));
}
template <>
inline const std::string& AlterTableType_Name(AlterTableType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<AlterTableType_descriptor,
                                                 0, 66>(
      static_cast<int>(value));
}
inline bool AlterTableType_Parse(absl::string_view name, AlterTableType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  GrantTargetType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool GrantTargetType_IsValid(int value);
extern const uint32_t GrantTargetType_internal_data_[];
constexpr GrantTargetType GrantTargetType_MIN = static_cast<GrantTargetType>(0);
constexpr GrantTargetType GrantTargetType_MAX = static_cast<GrantTargetType>(3);
constexpr int GrantTargetType_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
GrantTargetType_descriptor();
template <typename T>
const std::string& GrantTargetType_Name(T value) {
  static_assert(std::is_same<T, GrantTargetType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to GrantTargetType_Name().");
  return GrantTargetType_Name(static_cast<GrantTargetType>(value));
}
template <>
inline const std::string& GrantTargetType_Name(GrantTargetType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<GrantTargetType_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool GrantTargetType_Parse(absl::string_view name, GrantTargetType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  VariableSetKind_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool VariableSetKind_IsValid(int value);
extern const uint32_t VariableSetKind_internal_data_[];
constexpr VariableSetKind VariableSetKind_MIN = static_cast<VariableSetKind>(0);
constexpr VariableSetKind VariableSetKind_MAX = static_cast<VariableSetKind>(6);
constexpr int VariableSetKind_ARRAYSIZE = 6 + 1;
const ::google::protobuf::EnumDescriptor*
VariableSetKind_descriptor();
template <typename T>
const std::string& VariableSetKind_Name(T value) {
  static_assert(std::is_same<T, VariableSetKind>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to VariableSetKind_Name().");
  return VariableSetKind_Name(static_cast<VariableSetKind>(value));
}
template <>
inline const std::string& VariableSetKind_Name(VariableSetKind value) {
  return ::google::protobuf::internal::NameOfDenseEnum<VariableSetKind_descriptor,
                                                 0, 6>(
      static_cast<int>(value));
}
inline bool VariableSetKind_Parse(absl::string_view name, VariableSetKind* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  ConstrType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool ConstrType_IsValid(int value);
extern const uint32_t ConstrType_internal_data_[];
constexpr ConstrType ConstrType_MIN = static_cast<ConstrType>(0);
constexpr ConstrType ConstrType_MAX = static_cast<ConstrType>(14);
constexpr int ConstrType_ARRAYSIZE = 14 + 1;
const ::google::protobuf::EnumDescriptor*
ConstrType_descriptor();
template <typename T>
const std::string& ConstrType_Name(T value) {
  static_assert(std::is_same<T, ConstrType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to ConstrType_Name().");
  return ConstrType_Name(static_cast<ConstrType>(value));
}
template <>
inline const std::string& ConstrType_Name(ConstrType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<ConstrType_descriptor,
                                                 0, 14>(
      static_cast<int>(value));
}
inline bool ConstrType_Parse(absl::string_view name, ConstrType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  ImportForeignSchemaType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool ImportForeignSchemaType_IsValid(int value);
extern const uint32_t ImportForeignSchemaType_internal_data_[];
constexpr ImportForeignSchemaType ImportForeignSchemaType_MIN = static_cast<ImportForeignSchemaType>(0);
constexpr ImportForeignSchemaType ImportForeignSchemaType_MAX = static_cast<ImportForeignSchemaType>(3);
constexpr int ImportForeignSchemaType_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
ImportForeignSchemaType_descriptor();
template <typename T>
const std::string& ImportForeignSchemaType_Name(T value) {
  static_assert(std::is_same<T, ImportForeignSchemaType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to ImportForeignSchemaType_Name().");
  return ImportForeignSchemaType_Name(static_cast<ImportForeignSchemaType>(value));
}
template <>
inline const std::string& ImportForeignSchemaType_Name(ImportForeignSchemaType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<ImportForeignSchemaType_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool ImportForeignSchemaType_Parse(absl::string_view name, ImportForeignSchemaType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  RoleStmtType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool RoleStmtType_IsValid(int value);
extern const uint32_t RoleStmtType_internal_data_[];
constexpr RoleStmtType RoleStmtType_MIN = static_cast<RoleStmtType>(0);
constexpr RoleStmtType RoleStmtType_MAX = static_cast<RoleStmtType>(3);
constexpr int RoleStmtType_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
RoleStmtType_descriptor();
template <typename T>
const std::string& RoleStmtType_Name(T value) {
  static_assert(std::is_same<T, RoleStmtType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to RoleStmtType_Name().");
  return RoleStmtType_Name(static_cast<RoleStmtType>(value));
}
template <>
inline const std::string& RoleStmtType_Name(RoleStmtType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<RoleStmtType_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool RoleStmtType_Parse(absl::string_view name, RoleStmtType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  FetchDirection_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool FetchDirection_IsValid(int value);
extern const uint32_t FetchDirection_internal_data_[];
constexpr FetchDirection FetchDirection_MIN = static_cast<FetchDirection>(0);
constexpr FetchDirection FetchDirection_MAX = static_cast<FetchDirection>(4);
constexpr int FetchDirection_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
FetchDirection_descriptor();
template <typename T>
const std::string& FetchDirection_Name(T value) {
  static_assert(std::is_same<T, FetchDirection>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to FetchDirection_Name().");
  return FetchDirection_Name(static_cast<FetchDirection>(value));
}
template <>
inline const std::string& FetchDirection_Name(FetchDirection value) {
  return ::google::protobuf::internal::NameOfDenseEnum<FetchDirection_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool FetchDirection_Parse(absl::string_view name, FetchDirection* value) {
  return ::google::protobuf::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,
  FUNC_PARAM_DEFAULT = 6,
  FunctionParameterMode_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  FunctionParameterMode_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool FunctionParameterMode_IsValid(int value);
extern const uint32_t FunctionParameterMode_internal_data_[];
constexpr FunctionParameterMode FunctionParameterMode_MIN = static_cast<FunctionParameterMode>(0);
constexpr FunctionParameterMode FunctionParameterMode_MAX = static_cast<FunctionParameterMode>(6);
constexpr int FunctionParameterMode_ARRAYSIZE = 6 + 1;
const ::google::protobuf::EnumDescriptor*
FunctionParameterMode_descriptor();
template <typename T>
const std::string& FunctionParameterMode_Name(T value) {
  static_assert(std::is_same<T, FunctionParameterMode>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to FunctionParameterMode_Name().");
  return FunctionParameterMode_Name(static_cast<FunctionParameterMode>(value));
}
template <>
inline const std::string& FunctionParameterMode_Name(FunctionParameterMode value) {
  return ::google::protobuf::internal::NameOfDenseEnum<FunctionParameterMode_descriptor,
                                                 0, 6>(
      static_cast<int>(value));
}
inline bool FunctionParameterMode_Parse(absl::string_view name, FunctionParameterMode* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  TransactionStmtKind_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool TransactionStmtKind_IsValid(int value);
extern const uint32_t TransactionStmtKind_internal_data_[];
constexpr TransactionStmtKind TransactionStmtKind_MIN = static_cast<TransactionStmtKind>(0);
constexpr TransactionStmtKind TransactionStmtKind_MAX = static_cast<TransactionStmtKind>(10);
constexpr int TransactionStmtKind_ARRAYSIZE = 10 + 1;
const ::google::protobuf::EnumDescriptor*
TransactionStmtKind_descriptor();
template <typename T>
const std::string& TransactionStmtKind_Name(T value) {
  static_assert(std::is_same<T, TransactionStmtKind>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to TransactionStmtKind_Name().");
  return TransactionStmtKind_Name(static_cast<TransactionStmtKind>(value));
}
template <>
inline const std::string& TransactionStmtKind_Name(TransactionStmtKind value) {
  return ::google::protobuf::internal::NameOfDenseEnum<TransactionStmtKind_descriptor,
                                                 0, 10>(
      static_cast<int>(value));
}
inline bool TransactionStmtKind_Parse(absl::string_view name, TransactionStmtKind* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  ViewCheckOption_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool ViewCheckOption_IsValid(int value);
extern const uint32_t ViewCheckOption_internal_data_[];
constexpr ViewCheckOption ViewCheckOption_MIN = static_cast<ViewCheckOption>(0);
constexpr ViewCheckOption ViewCheckOption_MAX = static_cast<ViewCheckOption>(3);
constexpr int ViewCheckOption_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
ViewCheckOption_descriptor();
template <typename T>
const std::string& ViewCheckOption_Name(T value) {
  static_assert(std::is_same<T, ViewCheckOption>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to ViewCheckOption_Name().");
  return ViewCheckOption_Name(static_cast<ViewCheckOption>(value));
}
template <>
inline const std::string& ViewCheckOption_Name(ViewCheckOption value) {
  return ::google::protobuf::internal::NameOfDenseEnum<ViewCheckOption_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool ViewCheckOption_Parse(absl::string_view name, ViewCheckOption* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ViewCheckOption>(
      ViewCheckOption_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<::int32_t>::min(),
  DiscardMode_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool DiscardMode_IsValid(int value);
extern const uint32_t DiscardMode_internal_data_[];
constexpr DiscardMode DiscardMode_MIN = static_cast<DiscardMode>(0);
constexpr DiscardMode DiscardMode_MAX = static_cast<DiscardMode>(4);
constexpr int DiscardMode_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
DiscardMode_descriptor();
template <typename T>
const std::string& DiscardMode_Name(T value) {
  static_assert(std::is_same<T, DiscardMode>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to DiscardMode_Name().");
  return DiscardMode_Name(static_cast<DiscardMode>(value));
}
template <>
inline const std::string& DiscardMode_Name(DiscardMode value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DiscardMode_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool DiscardMode_Parse(absl::string_view name, DiscardMode* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  ReindexObjectType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool ReindexObjectType_IsValid(int value);
extern const uint32_t ReindexObjectType_internal_data_[];
constexpr ReindexObjectType ReindexObjectType_MIN = static_cast<ReindexObjectType>(0);
constexpr ReindexObjectType ReindexObjectType_MAX = static_cast<ReindexObjectType>(5);
constexpr int ReindexObjectType_ARRAYSIZE = 5 + 1;
const ::google::protobuf::EnumDescriptor*
ReindexObjectType_descriptor();
template <typename T>
const std::string& ReindexObjectType_Name(T value) {
  static_assert(std::is_same<T, ReindexObjectType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to ReindexObjectType_Name().");
  return ReindexObjectType_Name(static_cast<ReindexObjectType>(value));
}
template <>
inline const std::string& ReindexObjectType_Name(ReindexObjectType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<ReindexObjectType_descriptor,
                                                 0, 5>(
      static_cast<int>(value));
}
inline bool ReindexObjectType_Parse(absl::string_view name, ReindexObjectType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  AlterTSConfigType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool AlterTSConfigType_IsValid(int value);
extern const uint32_t AlterTSConfigType_internal_data_[];
constexpr AlterTSConfigType AlterTSConfigType_MIN = static_cast<AlterTSConfigType>(0);
constexpr AlterTSConfigType AlterTSConfigType_MAX = static_cast<AlterTSConfigType>(5);
constexpr int AlterTSConfigType_ARRAYSIZE = 5 + 1;
const ::google::protobuf::EnumDescriptor*
AlterTSConfigType_descriptor();
template <typename T>
const std::string& AlterTSConfigType_Name(T value) {
  static_assert(std::is_same<T, AlterTSConfigType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to AlterTSConfigType_Name().");
  return AlterTSConfigType_Name(static_cast<AlterTSConfigType>(value));
}
template <>
inline const std::string& AlterTSConfigType_Name(AlterTSConfigType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<AlterTSConfigType_descriptor,
                                                 0, 5>(
      static_cast<int>(value));
}
inline bool AlterTSConfigType_Parse(absl::string_view name, AlterTSConfigType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<AlterTSConfigType>(
      AlterTSConfigType_descriptor(), name, value);
}
enum PublicationObjSpecType : int {
  PUBLICATION_OBJ_SPEC_TYPE_UNDEFINED = 0,
  PUBLICATIONOBJ_TABLE = 1,
  PUBLICATIONOBJ_TABLES_IN_SCHEMA = 2,
  PUBLICATIONOBJ_TABLES_IN_CUR_SCHEMA = 3,
  PUBLICATIONOBJ_CONTINUATION = 4,
  PublicationObjSpecType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  PublicationObjSpecType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool PublicationObjSpecType_IsValid(int value);
extern const uint32_t PublicationObjSpecType_internal_data_[];
constexpr PublicationObjSpecType PublicationObjSpecType_MIN = static_cast<PublicationObjSpecType>(0);
constexpr PublicationObjSpecType PublicationObjSpecType_MAX = static_cast<PublicationObjSpecType>(4);
constexpr int PublicationObjSpecType_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
PublicationObjSpecType_descriptor();
template <typename T>
const std::string& PublicationObjSpecType_Name(T value) {
  static_assert(std::is_same<T, PublicationObjSpecType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to PublicationObjSpecType_Name().");
  return PublicationObjSpecType_Name(static_cast<PublicationObjSpecType>(value));
}
template <>
inline const std::string& PublicationObjSpecType_Name(PublicationObjSpecType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<PublicationObjSpecType_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool PublicationObjSpecType_Parse(absl::string_view name, PublicationObjSpecType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<PublicationObjSpecType>(
      PublicationObjSpecType_descriptor(), name, value);
}
enum AlterPublicationAction : int {
  ALTER_PUBLICATION_ACTION_UNDEFINED = 0,
  AP_AddObjects = 1,
  AP_DropObjects = 2,
  AP_SetObjects = 3,
  AlterPublicationAction_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  AlterPublicationAction_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool AlterPublicationAction_IsValid(int value);
extern const uint32_t AlterPublicationAction_internal_data_[];
constexpr AlterPublicationAction AlterPublicationAction_MIN = static_cast<AlterPublicationAction>(0);
constexpr AlterPublicationAction AlterPublicationAction_MAX = static_cast<AlterPublicationAction>(3);
constexpr int AlterPublicationAction_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
AlterPublicationAction_descriptor();
template <typename T>
const std::string& AlterPublicationAction_Name(T value) {
  static_assert(std::is_same<T, AlterPublicationAction>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to AlterPublicationAction_Name().");
  return AlterPublicationAction_Name(static_cast<AlterPublicationAction>(value));
}
template <>
inline const std::string& AlterPublicationAction_Name(AlterPublicationAction value) {
  return ::google::protobuf::internal::NameOfDenseEnum<AlterPublicationAction_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool AlterPublicationAction_Parse(absl::string_view name, AlterPublicationAction* value) {
  return ::google::protobuf::internal::ParseNamedEnum<AlterPublicationAction>(
      AlterPublicationAction_descriptor(), name, value);
}
enum AlterSubscriptionType : int {
  ALTER_SUBSCRIPTION_TYPE_UNDEFINED = 0,
  ALTER_SUBSCRIPTION_OPTIONS = 1,
  ALTER_SUBSCRIPTION_CONNECTION = 2,
  ALTER_SUBSCRIPTION_SET_PUBLICATION = 3,
  ALTER_SUBSCRIPTION_ADD_PUBLICATION = 4,
  ALTER_SUBSCRIPTION_DROP_PUBLICATION = 5,
  ALTER_SUBSCRIPTION_REFRESH = 6,
  ALTER_SUBSCRIPTION_ENABLED = 7,
  ALTER_SUBSCRIPTION_SKIP = 8,
  AlterSubscriptionType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  AlterSubscriptionType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool AlterSubscriptionType_IsValid(int value);
extern const uint32_t AlterSubscriptionType_internal_data_[];
constexpr AlterSubscriptionType AlterSubscriptionType_MIN = static_cast<AlterSubscriptionType>(0);
constexpr AlterSubscriptionType AlterSubscriptionType_MAX = static_cast<AlterSubscriptionType>(8);
constexpr int AlterSubscriptionType_ARRAYSIZE = 8 + 1;
const ::google::protobuf::EnumDescriptor*
AlterSubscriptionType_descriptor();
template <typename T>
const std::string& AlterSubscriptionType_Name(T value) {
  static_assert(std::is_same<T, AlterSubscriptionType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to AlterSubscriptionType_Name().");
  return AlterSubscriptionType_Name(static_cast<AlterSubscriptionType>(value));
}
template <>
inline const std::string& AlterSubscriptionType_Name(AlterSubscriptionType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<AlterSubscriptionType_descriptor,
                                                 0, 8>(
      static_cast<int>(value));
}
inline bool AlterSubscriptionType_Parse(absl::string_view name, AlterSubscriptionType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  OnCommitAction_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool OnCommitAction_IsValid(int value);
extern const uint32_t OnCommitAction_internal_data_[];
constexpr OnCommitAction OnCommitAction_MIN = static_cast<OnCommitAction>(0);
constexpr OnCommitAction OnCommitAction_MAX = static_cast<OnCommitAction>(4);
constexpr int OnCommitAction_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
OnCommitAction_descriptor();
template <typename T>
const std::string& OnCommitAction_Name(T value) {
  static_assert(std::is_same<T, OnCommitAction>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to OnCommitAction_Name().");
  return OnCommitAction_Name(static_cast<OnCommitAction>(value));
}
template <>
inline const std::string& OnCommitAction_Name(OnCommitAction value) {
  return ::google::protobuf::internal::NameOfDenseEnum<OnCommitAction_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool OnCommitAction_Parse(absl::string_view name, OnCommitAction* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  ParamKind_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool ParamKind_IsValid(int value);
extern const uint32_t ParamKind_internal_data_[];
constexpr ParamKind ParamKind_MIN = static_cast<ParamKind>(0);
constexpr ParamKind ParamKind_MAX = static_cast<ParamKind>(4);
constexpr int ParamKind_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
ParamKind_descriptor();
template <typename T>
const std::string& ParamKind_Name(T value) {
  static_assert(std::is_same<T, ParamKind>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to ParamKind_Name().");
  return ParamKind_Name(static_cast<ParamKind>(value));
}
template <>
inline const std::string& ParamKind_Name(ParamKind value) {
  return ::google::protobuf::internal::NameOfDenseEnum<ParamKind_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool ParamKind_Parse(absl::string_view name, ParamKind* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ParamKind>(
      ParamKind_descriptor(), name, value);
}
enum CoercionContext : int {
  COERCION_CONTEXT_UNDEFINED = 0,
  COERCION_IMPLICIT = 1,
  COERCION_ASSIGNMENT = 2,
  COERCION_PLPGSQL = 3,
  COERCION_EXPLICIT = 4,
  CoercionContext_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  CoercionContext_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool CoercionContext_IsValid(int value);
extern const uint32_t CoercionContext_internal_data_[];
constexpr CoercionContext CoercionContext_MIN = static_cast<CoercionContext>(0);
constexpr CoercionContext CoercionContext_MAX = static_cast<CoercionContext>(4);
constexpr int CoercionContext_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
CoercionContext_descriptor();
template <typename T>
const std::string& CoercionContext_Name(T value) {
  static_assert(std::is_same<T, CoercionContext>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to CoercionContext_Name().");
  return CoercionContext_Name(static_cast<CoercionContext>(value));
}
template <>
inline const std::string& CoercionContext_Name(CoercionContext value) {
  return ::google::protobuf::internal::NameOfDenseEnum<CoercionContext_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool CoercionContext_Parse(absl::string_view name, CoercionContext* value) {
  return ::google::protobuf::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,
  COERCE_SQL_SYNTAX = 4,
  CoercionForm_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  CoercionForm_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool CoercionForm_IsValid(int value);
extern const uint32_t CoercionForm_internal_data_[];
constexpr CoercionForm CoercionForm_MIN = static_cast<CoercionForm>(0);
constexpr CoercionForm CoercionForm_MAX = static_cast<CoercionForm>(4);
constexpr int CoercionForm_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
CoercionForm_descriptor();
template <typename T>
const std::string& CoercionForm_Name(T value) {
  static_assert(std::is_same<T, CoercionForm>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to CoercionForm_Name().");
  return CoercionForm_Name(static_cast<CoercionForm>(value));
}
template <>
inline const std::string& CoercionForm_Name(CoercionForm value) {
  return ::google::protobuf::internal::NameOfDenseEnum<CoercionForm_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool CoercionForm_Parse(absl::string_view name, CoercionForm* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  BoolExprType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool BoolExprType_IsValid(int value);
extern const uint32_t BoolExprType_internal_data_[];
constexpr BoolExprType BoolExprType_MIN = static_cast<BoolExprType>(0);
constexpr BoolExprType BoolExprType_MAX = static_cast<BoolExprType>(3);
constexpr int BoolExprType_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
BoolExprType_descriptor();
template <typename T>
const std::string& BoolExprType_Name(T value) {
  static_assert(std::is_same<T, BoolExprType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to BoolExprType_Name().");
  return BoolExprType_Name(static_cast<BoolExprType>(value));
}
template <>
inline const std::string& BoolExprType_Name(BoolExprType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<BoolExprType_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool BoolExprType_Parse(absl::string_view name, BoolExprType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  SubLinkType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool SubLinkType_IsValid(int value);
extern const uint32_t SubLinkType_internal_data_[];
constexpr SubLinkType SubLinkType_MIN = static_cast<SubLinkType>(0);
constexpr SubLinkType SubLinkType_MAX = static_cast<SubLinkType>(8);
constexpr int SubLinkType_ARRAYSIZE = 8 + 1;
const ::google::protobuf::EnumDescriptor*
SubLinkType_descriptor();
template <typename T>
const std::string& SubLinkType_Name(T value) {
  static_assert(std::is_same<T, SubLinkType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to SubLinkType_Name().");
  return SubLinkType_Name(static_cast<SubLinkType>(value));
}
template <>
inline const std::string& SubLinkType_Name(SubLinkType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SubLinkType_descriptor,
                                                 0, 8>(
      static_cast<int>(value));
}
inline bool SubLinkType_Parse(absl::string_view name, SubLinkType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  RowCompareType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool RowCompareType_IsValid(int value);
extern const uint32_t RowCompareType_internal_data_[];
constexpr RowCompareType RowCompareType_MIN = static_cast<RowCompareType>(0);
constexpr RowCompareType RowCompareType_MAX = static_cast<RowCompareType>(6);
constexpr int RowCompareType_ARRAYSIZE = 6 + 1;
const ::google::protobuf::EnumDescriptor*
RowCompareType_descriptor();
template <typename T>
const std::string& RowCompareType_Name(T value) {
  static_assert(std::is_same<T, RowCompareType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to RowCompareType_Name().");
  return RowCompareType_Name(static_cast<RowCompareType>(value));
}
template <>
inline const std::string& RowCompareType_Name(RowCompareType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<RowCompareType_descriptor,
                                                 0, 6>(
      static_cast<int>(value));
}
inline bool RowCompareType_Parse(absl::string_view name, RowCompareType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  MinMaxOp_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool MinMaxOp_IsValid(int value);
extern const uint32_t MinMaxOp_internal_data_[];
constexpr MinMaxOp MinMaxOp_MIN = static_cast<MinMaxOp>(0);
constexpr MinMaxOp MinMaxOp_MAX = static_cast<MinMaxOp>(2);
constexpr int MinMaxOp_ARRAYSIZE = 2 + 1;
const ::google::protobuf::EnumDescriptor*
MinMaxOp_descriptor();
template <typename T>
const std::string& MinMaxOp_Name(T value) {
  static_assert(std::is_same<T, MinMaxOp>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to MinMaxOp_Name().");
  return MinMaxOp_Name(static_cast<MinMaxOp>(value));
}
template <>
inline const std::string& MinMaxOp_Name(MinMaxOp value) {
  return ::google::protobuf::internal::NameOfDenseEnum<MinMaxOp_descriptor,
                                                 0, 2>(
      static_cast<int>(value));
}
inline bool MinMaxOp_Parse(absl::string_view name, MinMaxOp* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  SQLValueFunctionOp_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool SQLValueFunctionOp_IsValid(int value);
extern const uint32_t SQLValueFunctionOp_internal_data_[];
constexpr SQLValueFunctionOp SQLValueFunctionOp_MIN = static_cast<SQLValueFunctionOp>(0);
constexpr SQLValueFunctionOp SQLValueFunctionOp_MAX = static_cast<SQLValueFunctionOp>(15);
constexpr int SQLValueFunctionOp_ARRAYSIZE = 15 + 1;
const ::google::protobuf::EnumDescriptor*
SQLValueFunctionOp_descriptor();
template <typename T>
const std::string& SQLValueFunctionOp_Name(T value) {
  static_assert(std::is_same<T, SQLValueFunctionOp>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to SQLValueFunctionOp_Name().");
  return SQLValueFunctionOp_Name(static_cast<SQLValueFunctionOp>(value));
}
template <>
inline const std::string& SQLValueFunctionOp_Name(SQLValueFunctionOp value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SQLValueFunctionOp_descriptor,
                                                 0, 15>(
      static_cast<int>(value));
}
inline bool SQLValueFunctionOp_Parse(absl::string_view name, SQLValueFunctionOp* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  XmlExprOp_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool XmlExprOp_IsValid(int value);
extern const uint32_t XmlExprOp_internal_data_[];
constexpr XmlExprOp XmlExprOp_MIN = static_cast<XmlExprOp>(0);
constexpr XmlExprOp XmlExprOp_MAX = static_cast<XmlExprOp>(8);
constexpr int XmlExprOp_ARRAYSIZE = 8 + 1;
const ::google::protobuf::EnumDescriptor*
XmlExprOp_descriptor();
template <typename T>
const std::string& XmlExprOp_Name(T value) {
  static_assert(std::is_same<T, XmlExprOp>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to XmlExprOp_Name().");
  return XmlExprOp_Name(static_cast<XmlExprOp>(value));
}
template <>
inline const std::string& XmlExprOp_Name(XmlExprOp value) {
  return ::google::protobuf::internal::NameOfDenseEnum<XmlExprOp_descriptor,
                                                 0, 8>(
      static_cast<int>(value));
}
inline bool XmlExprOp_Parse(absl::string_view name, XmlExprOp* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  XmlOptionType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool XmlOptionType_IsValid(int value);
extern const uint32_t XmlOptionType_internal_data_[];
constexpr XmlOptionType XmlOptionType_MIN = static_cast<XmlOptionType>(0);
constexpr XmlOptionType XmlOptionType_MAX = static_cast<XmlOptionType>(2);
constexpr int XmlOptionType_ARRAYSIZE = 2 + 1;
const ::google::protobuf::EnumDescriptor*
XmlOptionType_descriptor();
template <typename T>
const std::string& XmlOptionType_Name(T value) {
  static_assert(std::is_same<T, XmlOptionType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to XmlOptionType_Name().");
  return XmlOptionType_Name(static_cast<XmlOptionType>(value));
}
template <>
inline const std::string& XmlOptionType_Name(XmlOptionType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<XmlOptionType_descriptor,
                                                 0, 2>(
      static_cast<int>(value));
}
inline bool XmlOptionType_Parse(absl::string_view name, XmlOptionType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<XmlOptionType>(
      XmlOptionType_descriptor(), name, value);
}
enum JsonEncoding : int {
  JSON_ENCODING_UNDEFINED = 0,
  JS_ENC_DEFAULT = 1,
  JS_ENC_UTF8 = 2,
  JS_ENC_UTF16 = 3,
  JS_ENC_UTF32 = 4,
  JsonEncoding_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  JsonEncoding_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool JsonEncoding_IsValid(int value);
extern const uint32_t JsonEncoding_internal_data_[];
constexpr JsonEncoding JsonEncoding_MIN = static_cast<JsonEncoding>(0);
constexpr JsonEncoding JsonEncoding_MAX = static_cast<JsonEncoding>(4);
constexpr int JsonEncoding_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
JsonEncoding_descriptor();
template <typename T>
const std::string& JsonEncoding_Name(T value) {
  static_assert(std::is_same<T, JsonEncoding>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to JsonEncoding_Name().");
  return JsonEncoding_Name(static_cast<JsonEncoding>(value));
}
template <>
inline const std::string& JsonEncoding_Name(JsonEncoding value) {
  return ::google::protobuf::internal::NameOfDenseEnum<JsonEncoding_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool JsonEncoding_Parse(absl::string_view name, JsonEncoding* value) {
  return ::google::protobuf::internal::ParseNamedEnum<JsonEncoding>(
      JsonEncoding_descriptor(), name, value);
}
enum JsonFormatType : int {
  JSON_FORMAT_TYPE_UNDEFINED = 0,
  JS_FORMAT_DEFAULT = 1,
  JS_FORMAT_JSON = 2,
  JS_FORMAT_JSONB = 3,
  JsonFormatType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  JsonFormatType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool JsonFormatType_IsValid(int value);
extern const uint32_t JsonFormatType_internal_data_[];
constexpr JsonFormatType JsonFormatType_MIN = static_cast<JsonFormatType>(0);
constexpr JsonFormatType JsonFormatType_MAX = static_cast<JsonFormatType>(3);
constexpr int JsonFormatType_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
JsonFormatType_descriptor();
template <typename T>
const std::string& JsonFormatType_Name(T value) {
  static_assert(std::is_same<T, JsonFormatType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to JsonFormatType_Name().");
  return JsonFormatType_Name(static_cast<JsonFormatType>(value));
}
template <>
inline const std::string& JsonFormatType_Name(JsonFormatType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<JsonFormatType_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool JsonFormatType_Parse(absl::string_view name, JsonFormatType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<JsonFormatType>(
      JsonFormatType_descriptor(), name, value);
}
enum JsonConstructorType : int {
  JSON_CONSTRUCTOR_TYPE_UNDEFINED = 0,
  JSCTOR_JSON_OBJECT = 1,
  JSCTOR_JSON_ARRAY = 2,
  JSCTOR_JSON_OBJECTAGG = 3,
  JSCTOR_JSON_ARRAYAGG = 4,
  JsonConstructorType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  JsonConstructorType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool JsonConstructorType_IsValid(int value);
extern const uint32_t JsonConstructorType_internal_data_[];
constexpr JsonConstructorType JsonConstructorType_MIN = static_cast<JsonConstructorType>(0);
constexpr JsonConstructorType JsonConstructorType_MAX = static_cast<JsonConstructorType>(4);
constexpr int JsonConstructorType_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
JsonConstructorType_descriptor();
template <typename T>
const std::string& JsonConstructorType_Name(T value) {
  static_assert(std::is_same<T, JsonConstructorType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to JsonConstructorType_Name().");
  return JsonConstructorType_Name(static_cast<JsonConstructorType>(value));
}
template <>
inline const std::string& JsonConstructorType_Name(JsonConstructorType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<JsonConstructorType_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool JsonConstructorType_Parse(absl::string_view name, JsonConstructorType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<JsonConstructorType>(
      JsonConstructorType_descriptor(), name, value);
}
enum JsonValueType : int {
  JSON_VALUE_TYPE_UNDEFINED = 0,
  JS_TYPE_ANY = 1,
  JS_TYPE_OBJECT = 2,
  JS_TYPE_ARRAY = 3,
  JS_TYPE_SCALAR = 4,
  JsonValueType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  JsonValueType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool JsonValueType_IsValid(int value);
extern const uint32_t JsonValueType_internal_data_[];
constexpr JsonValueType JsonValueType_MIN = static_cast<JsonValueType>(0);
constexpr JsonValueType JsonValueType_MAX = static_cast<JsonValueType>(4);
constexpr int JsonValueType_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
JsonValueType_descriptor();
template <typename T>
const std::string& JsonValueType_Name(T value) {
  static_assert(std::is_same<T, JsonValueType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to JsonValueType_Name().");
  return JsonValueType_Name(static_cast<JsonValueType>(value));
}
template <>
inline const std::string& JsonValueType_Name(JsonValueType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<JsonValueType_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool JsonValueType_Parse(absl::string_view name, JsonValueType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<JsonValueType>(
      JsonValueType_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<::int32_t>::min(),
  NullTestType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool NullTestType_IsValid(int value);
extern const uint32_t NullTestType_internal_data_[];
constexpr NullTestType NullTestType_MIN = static_cast<NullTestType>(0);
constexpr NullTestType NullTestType_MAX = static_cast<NullTestType>(2);
constexpr int NullTestType_ARRAYSIZE = 2 + 1;
const ::google::protobuf::EnumDescriptor*
NullTestType_descriptor();
template <typename T>
const std::string& NullTestType_Name(T value) {
  static_assert(std::is_same<T, NullTestType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to NullTestType_Name().");
  return NullTestType_Name(static_cast<NullTestType>(value));
}
template <>
inline const std::string& NullTestType_Name(NullTestType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<NullTestType_descriptor,
                                                 0, 2>(
      static_cast<int>(value));
}
inline bool NullTestType_Parse(absl::string_view name, NullTestType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  BoolTestType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool BoolTestType_IsValid(int value);
extern const uint32_t BoolTestType_internal_data_[];
constexpr BoolTestType BoolTestType_MIN = static_cast<BoolTestType>(0);
constexpr BoolTestType BoolTestType_MAX = static_cast<BoolTestType>(6);
constexpr int BoolTestType_ARRAYSIZE = 6 + 1;
const ::google::protobuf::EnumDescriptor*
BoolTestType_descriptor();
template <typename T>
const std::string& BoolTestType_Name(T value) {
  static_assert(std::is_same<T, BoolTestType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to BoolTestType_Name().");
  return BoolTestType_Name(static_cast<BoolTestType>(value));
}
template <>
inline const std::string& BoolTestType_Name(BoolTestType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<BoolTestType_descriptor,
                                                 0, 6>(
      static_cast<int>(value));
}
inline bool BoolTestType_Parse(absl::string_view name, BoolTestType* value) {
  return ::google::protobuf::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_MERGE = 6,
  CMD_UTILITY = 7,
  CMD_NOTHING = 8,
  CmdType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  CmdType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool CmdType_IsValid(int value);
extern const uint32_t CmdType_internal_data_[];
constexpr CmdType CmdType_MIN = static_cast<CmdType>(0);
constexpr CmdType CmdType_MAX = static_cast<CmdType>(8);
constexpr int CmdType_ARRAYSIZE = 8 + 1;
const ::google::protobuf::EnumDescriptor*
CmdType_descriptor();
template <typename T>
const std::string& CmdType_Name(T value) {
  static_assert(std::is_same<T, CmdType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to CmdType_Name().");
  return CmdType_Name(static_cast<CmdType>(value));
}
template <>
inline const std::string& CmdType_Name(CmdType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<CmdType_descriptor,
                                                 0, 8>(
      static_cast<int>(value));
}
inline bool CmdType_Parse(absl::string_view name, CmdType* value) {
  return ::google::protobuf::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_RIGHT_ANTI = 7,
  JOIN_UNIQUE_OUTER = 8,
  JOIN_UNIQUE_INNER = 9,
  JoinType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  JoinType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool JoinType_IsValid(int value);
extern const uint32_t JoinType_internal_data_[];
constexpr JoinType JoinType_MIN = static_cast<JoinType>(0);
constexpr JoinType JoinType_MAX = static_cast<JoinType>(9);
constexpr int JoinType_ARRAYSIZE = 9 + 1;
const ::google::protobuf::EnumDescriptor*
JoinType_descriptor();
template <typename T>
const std::string& JoinType_Name(T value) {
  static_assert(std::is_same<T, JoinType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to JoinType_Name().");
  return JoinType_Name(static_cast<JoinType>(value));
}
template <>
inline const std::string& JoinType_Name(JoinType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<JoinType_descriptor,
                                                 0, 9>(
      static_cast<int>(value));
}
inline bool JoinType_Parse(absl::string_view name, JoinType* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  AggStrategy_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool AggStrategy_IsValid(int value);
extern const uint32_t AggStrategy_internal_data_[];
constexpr AggStrategy AggStrategy_MIN = static_cast<AggStrategy>(0);
constexpr AggStrategy AggStrategy_MAX = static_cast<AggStrategy>(4);
constexpr int AggStrategy_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
AggStrategy_descriptor();
template <typename T>
const std::string& AggStrategy_Name(T value) {
  static_assert(std::is_same<T, AggStrategy>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to AggStrategy_Name().");
  return AggStrategy_Name(static_cast<AggStrategy>(value));
}
template <>
inline const std::string& AggStrategy_Name(AggStrategy value) {
  return ::google::protobuf::internal::NameOfDenseEnum<AggStrategy_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool AggStrategy_Parse(absl::string_view name, AggStrategy* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  AggSplit_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool AggSplit_IsValid(int value);
extern const uint32_t AggSplit_internal_data_[];
constexpr AggSplit AggSplit_MIN = static_cast<AggSplit>(0);
constexpr AggSplit AggSplit_MAX = static_cast<AggSplit>(3);
constexpr int AggSplit_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
AggSplit_descriptor();
template <typename T>
const std::string& AggSplit_Name(T value) {
  static_assert(std::is_same<T, AggSplit>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to AggSplit_Name().");
  return AggSplit_Name(static_cast<AggSplit>(value));
}
template <>
inline const std::string& AggSplit_Name(AggSplit value) {
  return ::google::protobuf::internal::NameOfDenseEnum<AggSplit_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool AggSplit_Parse(absl::string_view name, AggSplit* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  SetOpCmd_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool SetOpCmd_IsValid(int value);
extern const uint32_t SetOpCmd_internal_data_[];
constexpr SetOpCmd SetOpCmd_MIN = static_cast<SetOpCmd>(0);
constexpr SetOpCmd SetOpCmd_MAX = static_cast<SetOpCmd>(4);
constexpr int SetOpCmd_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
SetOpCmd_descriptor();
template <typename T>
const std::string& SetOpCmd_Name(T value) {
  static_assert(std::is_same<T, SetOpCmd>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to SetOpCmd_Name().");
  return SetOpCmd_Name(static_cast<SetOpCmd>(value));
}
template <>
inline const std::string& SetOpCmd_Name(SetOpCmd value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SetOpCmd_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool SetOpCmd_Parse(absl::string_view name, SetOpCmd* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  SetOpStrategy_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool SetOpStrategy_IsValid(int value);
extern const uint32_t SetOpStrategy_internal_data_[];
constexpr SetOpStrategy SetOpStrategy_MIN = static_cast<SetOpStrategy>(0);
constexpr SetOpStrategy SetOpStrategy_MAX = static_cast<SetOpStrategy>(2);
constexpr int SetOpStrategy_ARRAYSIZE = 2 + 1;
const ::google::protobuf::EnumDescriptor*
SetOpStrategy_descriptor();
template <typename T>
const std::string& SetOpStrategy_Name(T value) {
  static_assert(std::is_same<T, SetOpStrategy>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to SetOpStrategy_Name().");
  return SetOpStrategy_Name(static_cast<SetOpStrategy>(value));
}
template <>
inline const std::string& SetOpStrategy_Name(SetOpStrategy value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SetOpStrategy_descriptor,
                                                 0, 2>(
      static_cast<int>(value));
}
inline bool SetOpStrategy_Parse(absl::string_view name, SetOpStrategy* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  OnConflictAction_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool OnConflictAction_IsValid(int value);
extern const uint32_t OnConflictAction_internal_data_[];
constexpr OnConflictAction OnConflictAction_MIN = static_cast<OnConflictAction>(0);
constexpr OnConflictAction OnConflictAction_MAX = static_cast<OnConflictAction>(3);
constexpr int OnConflictAction_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
OnConflictAction_descriptor();
template <typename T>
const std::string& OnConflictAction_Name(T value) {
  static_assert(std::is_same<T, OnConflictAction>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to OnConflictAction_Name().");
  return OnConflictAction_Name(static_cast<OnConflictAction>(value));
}
template <>
inline const std::string& OnConflictAction_Name(OnConflictAction value) {
  return ::google::protobuf::internal::NameOfDenseEnum<OnConflictAction_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool OnConflictAction_Parse(absl::string_view name, OnConflictAction* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  LimitOption_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool LimitOption_IsValid(int value);
extern const uint32_t LimitOption_internal_data_[];
constexpr LimitOption LimitOption_MIN = static_cast<LimitOption>(0);
constexpr LimitOption LimitOption_MAX = static_cast<LimitOption>(3);
constexpr int LimitOption_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
LimitOption_descriptor();
template <typename T>
const std::string& LimitOption_Name(T value) {
  static_assert(std::is_same<T, LimitOption>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to LimitOption_Name().");
  return LimitOption_Name(static_cast<LimitOption>(value));
}
template <>
inline const std::string& LimitOption_Name(LimitOption value) {
  return ::google::protobuf::internal::NameOfDenseEnum<LimitOption_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool LimitOption_Parse(absl::string_view name, LimitOption* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  LockClauseStrength_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool LockClauseStrength_IsValid(int value);
extern const uint32_t LockClauseStrength_internal_data_[];
constexpr LockClauseStrength LockClauseStrength_MIN = static_cast<LockClauseStrength>(0);
constexpr LockClauseStrength LockClauseStrength_MAX = static_cast<LockClauseStrength>(5);
constexpr int LockClauseStrength_ARRAYSIZE = 5 + 1;
const ::google::protobuf::EnumDescriptor*
LockClauseStrength_descriptor();
template <typename T>
const std::string& LockClauseStrength_Name(T value) {
  static_assert(std::is_same<T, LockClauseStrength>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to LockClauseStrength_Name().");
  return LockClauseStrength_Name(static_cast<LockClauseStrength>(value));
}
template <>
inline const std::string& LockClauseStrength_Name(LockClauseStrength value) {
  return ::google::protobuf::internal::NameOfDenseEnum<LockClauseStrength_descriptor,
                                                 0, 5>(
      static_cast<int>(value));
}
inline bool LockClauseStrength_Parse(absl::string_view name, LockClauseStrength* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  LockWaitPolicy_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool LockWaitPolicy_IsValid(int value);
extern const uint32_t LockWaitPolicy_internal_data_[];
constexpr LockWaitPolicy LockWaitPolicy_MIN = static_cast<LockWaitPolicy>(0);
constexpr LockWaitPolicy LockWaitPolicy_MAX = static_cast<LockWaitPolicy>(3);
constexpr int LockWaitPolicy_ARRAYSIZE = 3 + 1;
const ::google::protobuf::EnumDescriptor*
LockWaitPolicy_descriptor();
template <typename T>
const std::string& LockWaitPolicy_Name(T value) {
  static_assert(std::is_same<T, LockWaitPolicy>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to LockWaitPolicy_Name().");
  return LockWaitPolicy_Name(static_cast<LockWaitPolicy>(value));
}
template <>
inline const std::string& LockWaitPolicy_Name(LockWaitPolicy value) {
  return ::google::protobuf::internal::NameOfDenseEnum<LockWaitPolicy_descriptor,
                                                 0, 3>(
      static_cast<int>(value));
}
inline bool LockWaitPolicy_Parse(absl::string_view name, LockWaitPolicy* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  LockTupleMode_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool LockTupleMode_IsValid(int value);
extern const uint32_t LockTupleMode_internal_data_[];
constexpr LockTupleMode LockTupleMode_MIN = static_cast<LockTupleMode>(0);
constexpr LockTupleMode LockTupleMode_MAX = static_cast<LockTupleMode>(4);
constexpr int LockTupleMode_ARRAYSIZE = 4 + 1;
const ::google::protobuf::EnumDescriptor*
LockTupleMode_descriptor();
template <typename T>
const std::string& LockTupleMode_Name(T value) {
  static_assert(std::is_same<T, LockTupleMode>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to LockTupleMode_Name().");
  return LockTupleMode_Name(static_cast<LockTupleMode>(value));
}
template <>
inline const std::string& LockTupleMode_Name(LockTupleMode value) {
  return ::google::protobuf::internal::NameOfDenseEnum<LockTupleMode_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool LockTupleMode_Parse(absl::string_view name, LockTupleMode* value) {
  return ::google::protobuf::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<::int32_t>::min(),
  KeywordKind_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

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

bool Token_IsValid(int value);
extern const uint32_t Token_internal_data_[];
constexpr Token Token_MIN = static_cast<Token>(0);
constexpr Token Token_MAX = static_cast<Token>(758);
constexpr int Token_ARRAYSIZE = 758 + 1;
const ::google::protobuf::EnumDescriptor*
Token_descriptor();
template <typename T>
const std::string& Token_Name(T value) {
  static_assert(std::is_same<T, Token>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to Token_Name().");
  return Token_Name(static_cast<Token>(value));
}
template <>
inline const std::string& Token_Name(Token value) {
  return ::google::protobuf::internal::NameOfDenseEnum<Token_descriptor,
                                                 0, 758>(
      static_cast<int>(value));
}
inline bool Token_Parse(absl::string_view name, Token* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Token>(
      Token_descriptor(), name, value);
}

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


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

class VariableShowStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.VariableShowStmt) */ {
 public:
  inline VariableShowStmt() : VariableShowStmt(nullptr) {}
  ~VariableShowStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR VariableShowStmt(::google::protobuf::internal::ConstantInitialized);

  inline VariableShowStmt(const VariableShowStmt& from)
      : VariableShowStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const VariableShowStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const VariableShowStmt* internal_default_instance() {
    return reinterpret_cast<const VariableShowStmt*>(
               &_VariableShowStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    148;

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

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

  VariableShowStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<VariableShowStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const VariableShowStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const VariableShowStmt& from) {
    VariableShowStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(VariableShowStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.VariableShowStmt";
  }
  protected:
  explicit VariableShowStmt(::google::protobuf::Arena* arena);
  VariableShowStmt(::google::protobuf::Arena* arena, const VariableShowStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kNameFieldNumber = 1,
  };
  // string name = 1 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      38, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr name_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class UnlistenStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.UnlistenStmt) */ {
 public:
  inline UnlistenStmt() : UnlistenStmt(nullptr) {}
  ~UnlistenStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR UnlistenStmt(::google::protobuf::internal::ConstantInitialized);

  inline UnlistenStmt(const UnlistenStmt& from)
      : UnlistenStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const UnlistenStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const UnlistenStmt* internal_default_instance() {
    return reinterpret_cast<const UnlistenStmt*>(
               &_UnlistenStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    213;

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

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

  UnlistenStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<UnlistenStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const UnlistenStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const UnlistenStmt& from) {
    UnlistenStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(UnlistenStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.UnlistenStmt";
  }
  protected:
  explicit UnlistenStmt(::google::protobuf::Arena* arena);
  UnlistenStmt(::google::protobuf::Arena* arena, const UnlistenStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kConditionnameFieldNumber = 1,
  };
  // string conditionname = 1 [json_name = "conditionname"];
  void clear_conditionname() ;
  const std::string& conditionname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_conditionname(Arg_&& arg, Args_... args);
  std::string* mutable_conditionname();
  PROTOBUF_NODISCARD std::string* release_conditionname();
  void set_allocated_conditionname(std::string* value);

  private:
  const std::string& _internal_conditionname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      43, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr conditionname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class TriggerTransition final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.TriggerTransition) */ {
 public:
  inline TriggerTransition() : TriggerTransition(nullptr) {}
  ~TriggerTransition() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR TriggerTransition(::google::protobuf::internal::ConstantInitialized);

  inline TriggerTransition(const TriggerTransition& from)
      : TriggerTransition(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TriggerTransition& default_instance() {
    return *internal_default_instance();
  }
  static inline const TriggerTransition* internal_default_instance() {
    return reinterpret_cast<const TriggerTransition*>(
               &_TriggerTransition_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    117;

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

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

  TriggerTransition* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TriggerTransition>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TriggerTransition& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const TriggerTransition& from) {
    TriggerTransition::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(TriggerTransition* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.TriggerTransition";
  }
  protected:
  explicit TriggerTransition(::google::protobuf::Arena* arena);
  TriggerTransition(::google::protobuf::Arena* arena, const TriggerTransition& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 0,
      39, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr name_;
    bool is_new_;
    bool is_table_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class String final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.String) */ {
 public:
  inline String() : String(nullptr) {}
  ~String() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR String(::google::protobuf::internal::ConstantInitialized);

  inline String(const String& from)
      : String(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

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

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

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

  String* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<String>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const String& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const String& from) {
    String::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(String* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.String";
  }
  protected:
  explicit String(::google::protobuf::Arena* arena);
  String(::google::protobuf::Arena* arena, const String& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSvalFieldNumber = 1,
  };
  // string sval = 1;
  void clear_sval() ;
  const std::string& sval() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_sval(Arg_&& arg, Args_... args);
  std::string* mutable_sval();
  PROTOBUF_NODISCARD std::string* release_sval();
  void set_allocated_sval(std::string* value);

  private:
  const std::string& _internal_sval() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sval(
      const std::string& value);
  std::string* _internal_mutable_sval();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      28, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr sval_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class SortGroupClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.SortGroupClause) */ {
 public:
  inline SortGroupClause() : SortGroupClause(nullptr) {}
  ~SortGroupClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SortGroupClause(::google::protobuf::internal::ConstantInitialized);

  inline SortGroupClause(const SortGroupClause& from)
      : SortGroupClause(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SortGroupClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const SortGroupClause* internal_default_instance() {
    return reinterpret_cast<const SortGroupClause*>(
               &_SortGroupClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    105;

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

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

  SortGroupClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SortGroupClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SortGroupClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const SortGroupClause& from) {
    SortGroupClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(SortGroupClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.SortGroupClause";
  }
  protected:
  explicit SortGroupClause(::google::protobuf::Arena* arena);
  SortGroupClause(::google::protobuf::Arena* arena, const SortGroupClause& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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() ;
  ::uint32_t tle_sort_group_ref() const;
  void set_tle_sort_group_ref(::uint32_t value);

  private:
  ::uint32_t _internal_tle_sort_group_ref() const;
  void _internal_set_tle_sort_group_ref(::uint32_t value);

  public:
  // uint32 eqop = 2 [json_name = "eqop"];
  void clear_eqop() ;
  ::uint32_t eqop() const;
  void set_eqop(::uint32_t value);

  private:
  ::uint32_t _internal_eqop() const;
  void _internal_set_eqop(::uint32_t value);

  public:
  // uint32 sortop = 3 [json_name = "sortop"];
  void clear_sortop() ;
  ::uint32_t sortop() const;
  void set_sortop(::uint32_t value);

  private:
  ::uint32_t _internal_sortop() const;
  void _internal_set_sortop(::uint32_t 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::uint32_t tle_sort_group_ref_;
    ::uint32_t eqop_;
    ::uint32_t sortop_;
    bool nulls_first_;
    bool hashable_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ScanToken final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ScanToken) */ {
 public:
  inline ScanToken() : ScanToken(nullptr) {}
  ~ScanToken() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ScanToken(::google::protobuf::internal::ConstantInitialized);

  inline ScanToken(const ScanToken& from)
      : ScanToken(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ScanToken& default_instance() {
    return *internal_default_instance();
  }
  static inline const ScanToken* internal_default_instance() {
    return reinterpret_cast<const ScanToken*>(
               &_ScanToken_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    255;

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

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

  ScanToken* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ScanToken>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ScanToken& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ScanToken& from) {
    ScanToken::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ScanToken* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ScanToken";
  }
  protected:
  explicit ScanToken(::google::protobuf::Arena* arena);
  ScanToken(::google::protobuf::Arena* arena, const ScanToken& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kStartFieldNumber = 1,
    kEndFieldNumber = 2,
    kTokenFieldNumber = 4,
    kKeywordKindFieldNumber = 5,
  };
  // int32 start = 1;
  void clear_start() ;
  ::int32_t start() const;
  void set_start(::int32_t value);

  private:
  ::int32_t _internal_start() const;
  void _internal_set_start(::int32_t value);

  public:
  // int32 end = 2;
  void clear_end() ;
  ::int32_t end() const;
  void set_end(::int32_t value);

  private:
  ::int32_t _internal_end() const;
  void _internal_set_end(::int32_t 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 4, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::int32_t start_;
    ::int32_t end_;
    int token_;
    int keyword_kind_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RowMarkClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RowMarkClause) */ {
 public:
  inline RowMarkClause() : RowMarkClause(nullptr) {}
  ~RowMarkClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RowMarkClause(::google::protobuf::internal::ConstantInitialized);

  inline RowMarkClause(const RowMarkClause& from)
      : RowMarkClause(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RowMarkClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const RowMarkClause* internal_default_instance() {
    return reinterpret_cast<const RowMarkClause*>(
               &_RowMarkClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    108;

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

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

  RowMarkClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RowMarkClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RowMarkClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RowMarkClause& from) {
    RowMarkClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RowMarkClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RowMarkClause";
  }
  protected:
  explicit RowMarkClause(::google::protobuf::Arena* arena);
  RowMarkClause(::google::protobuf::Arena* arena, const RowMarkClause& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kRtiFieldNumber = 1,
    kStrengthFieldNumber = 2,
    kWaitPolicyFieldNumber = 3,
    kPushedDownFieldNumber = 4,
  };
  // uint32 rti = 1 [json_name = "rti"];
  void clear_rti() ;
  ::uint32_t rti() const;
  void set_rti(::uint32_t value);

  private:
  ::uint32_t _internal_rti() const;
  void _internal_set_rti(::uint32_t 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::uint32_t rti_;
    int strength_;
    int wait_policy_;
    bool pushed_down_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RoleSpec final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RoleSpec) */ {
 public:
  inline RoleSpec() : RoleSpec(nullptr) {}
  ~RoleSpec() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RoleSpec(::google::protobuf::internal::ConstantInitialized);

  inline RoleSpec(const RoleSpec& from)
      : RoleSpec(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RoleSpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const RoleSpec* internal_default_instance() {
    return reinterpret_cast<const RoleSpec*>(
               &_RoleSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    74;

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

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

  RoleSpec* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RoleSpec>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RoleSpec& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RoleSpec& from) {
    RoleSpec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RoleSpec* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RoleSpec";
  }
  protected:
  explicit RoleSpec(::google::protobuf::Arena* arena);
  RoleSpec(::google::protobuf::Arena* arena, const RoleSpec& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_rolename(Arg_&& arg, Args_... args);
  std::string* mutable_rolename();
  PROTOBUF_NODISCARD std::string* release_rolename();
  void set_allocated_rolename(std::string* value);

  private:
  const std::string& _internal_rolename() const;
  inline PROTOBUF_ALWAYS_INLINE 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 0,
      34, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr rolename_;
    int roletype_;
    ::int32_t location_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ReplicaIdentityStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ReplicaIdentityStmt) */ {
 public:
  inline ReplicaIdentityStmt() : ReplicaIdentityStmt(nullptr) {}
  ~ReplicaIdentityStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ReplicaIdentityStmt(::google::protobuf::internal::ConstantInitialized);

  inline ReplicaIdentityStmt(const ReplicaIdentityStmt& from)
      : ReplicaIdentityStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ReplicaIdentityStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReplicaIdentityStmt* internal_default_instance() {
    return reinterpret_cast<const ReplicaIdentityStmt*>(
               &_ReplicaIdentityStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    137;

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

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

  ReplicaIdentityStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReplicaIdentityStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ReplicaIdentityStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ReplicaIdentityStmt& from) {
    ReplicaIdentityStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ReplicaIdentityStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ReplicaIdentityStmt";
  }
  protected:
  explicit ReplicaIdentityStmt(::google::protobuf::Arena* arena);
  ReplicaIdentityStmt(::google::protobuf::Arena* arena, const ReplicaIdentityStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_identity_type(Arg_&& arg, Args_... args);
  std::string* mutable_identity_type();
  PROTOBUF_NODISCARD std::string* release_identity_type();
  void set_allocated_identity_type(std::string* value);

  private:
  const std::string& _internal_identity_type() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      54, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr identity_type_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RangeTblRef final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTblRef) */ {
 public:
  inline RangeTblRef() : RangeTblRef(nullptr) {}
  ~RangeTblRef() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RangeTblRef(::google::protobuf::internal::ConstantInitialized);

  inline RangeTblRef(const RangeTblRef& from)
      : RangeTblRef(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RangeTblRef& default_instance() {
    return *internal_default_instance();
  }
  static inline const RangeTblRef* internal_default_instance() {
    return reinterpret_cast<const RangeTblRef*>(
               &_RangeTblRef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    63;

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

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

  RangeTblRef* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RangeTblRef>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RangeTblRef& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RangeTblRef& from) {
    RangeTblRef::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RangeTblRef* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RangeTblRef";
  }
  protected:
  explicit RangeTblRef(::google::protobuf::Arena* arena);
  RangeTblRef(::google::protobuf::Arena* arena, const RangeTblRef& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kRtindexFieldNumber = 1,
  };
  // int32 rtindex = 1 [json_name = "rtindex"];
  void clear_rtindex() ;
  ::int32_t rtindex() const;
  void set_rtindex(::int32_t value);

  private:
  ::int32_t _internal_rtindex() const;
  void _internal_set_rtindex(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::int32_t rtindex_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RTEPermissionInfo final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RTEPermissionInfo) */ {
 public:
  inline RTEPermissionInfo() : RTEPermissionInfo(nullptr) {}
  ~RTEPermissionInfo() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RTEPermissionInfo(::google::protobuf::internal::ConstantInitialized);

  inline RTEPermissionInfo(const RTEPermissionInfo& from)
      : RTEPermissionInfo(nullptr, from) {}
  RTEPermissionInfo(RTEPermissionInfo&& from) noexcept
    : RTEPermissionInfo() {
    *this = ::std::move(from);
  }

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

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RTEPermissionInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const RTEPermissionInfo* internal_default_instance() {
    return reinterpret_cast<const RTEPermissionInfo*>(
               &_RTEPermissionInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    101;

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

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

  RTEPermissionInfo* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RTEPermissionInfo>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RTEPermissionInfo& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RTEPermissionInfo& from) {
    RTEPermissionInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RTEPermissionInfo* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RTEPermissionInfo";
  }
  protected:
  explicit RTEPermissionInfo(::google::protobuf::Arena* arena);
  RTEPermissionInfo(::google::protobuf::Arena* arena, const RTEPermissionInfo& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSelectedColsFieldNumber = 5,
    kInsertedColsFieldNumber = 6,
    kUpdatedColsFieldNumber = 7,
    kRelidFieldNumber = 1,
    kInhFieldNumber = 2,
    kRequiredPermsFieldNumber = 3,
    kCheckAsUserFieldNumber = 4,
  };
  // repeated uint64 selected_cols = 5 [json_name = "selectedCols"];
  int selected_cols_size() const;
  private:
  int _internal_selected_cols_size() const;

  public:
  void clear_selected_cols() ;
  ::uint64_t selected_cols(int index) const;
  void set_selected_cols(int index, ::uint64_t value);
  void add_selected_cols(::uint64_t value);
  const ::google::protobuf::RepeatedField<::uint64_t>& selected_cols() const;
  ::google::protobuf::RepeatedField<::uint64_t>* mutable_selected_cols();

  private:
  const ::google::protobuf::RepeatedField<::uint64_t>& _internal_selected_cols() const;
  ::google::protobuf::RepeatedField<::uint64_t>* _internal_mutable_selected_cols();

  public:
  // repeated uint64 inserted_cols = 6 [json_name = "insertedCols"];
  int inserted_cols_size() const;
  private:
  int _internal_inserted_cols_size() const;

  public:
  void clear_inserted_cols() ;
  ::uint64_t inserted_cols(int index) const;
  void set_inserted_cols(int index, ::uint64_t value);
  void add_inserted_cols(::uint64_t value);
  const ::google::protobuf::RepeatedField<::uint64_t>& inserted_cols() const;
  ::google::protobuf::RepeatedField<::uint64_t>* mutable_inserted_cols();

  private:
  const ::google::protobuf::RepeatedField<::uint64_t>& _internal_inserted_cols() const;
  ::google::protobuf::RepeatedField<::uint64_t>* _internal_mutable_inserted_cols();

  public:
  // repeated uint64 updated_cols = 7 [json_name = "updatedCols"];
  int updated_cols_size() const;
  private:
  int _internal_updated_cols_size() const;

  public:
  void clear_updated_cols() ;
  ::uint64_t updated_cols(int index) const;
  void set_updated_cols(int index, ::uint64_t value);
  void add_updated_cols(::uint64_t value);
  const ::google::protobuf::RepeatedField<::uint64_t>& updated_cols() const;
  ::google::protobuf::RepeatedField<::uint64_t>* mutable_updated_cols();

  private:
  const ::google::protobuf::RepeatedField<::uint64_t>& _internal_updated_cols() const;
  ::google::protobuf::RepeatedField<::uint64_t>* _internal_mutable_updated_cols();

  public:
  // uint32 relid = 1 [json_name = "relid"];
  void clear_relid() ;
  ::uint32_t relid() const;
  void set_relid(::uint32_t value);

  private:
  ::uint32_t _internal_relid() const;
  void _internal_set_relid(::uint32_t value);

  public:
  // bool inh = 2 [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:
  // int64 required_perms = 3 [json_name = "requiredPerms"];
  void clear_required_perms() ;
  ::int64_t required_perms() const;
  void set_required_perms(::int64_t value);

  private:
  ::int64_t _internal_required_perms() const;
  void _internal_set_required_perms(::int64_t value);

  public:
  // uint32 check_as_user = 4 [json_name = "checkAsUser"];
  void clear_check_as_user() ;
  ::uint32_t check_as_user() const;
  void set_check_as_user(::uint32_t value);

  private:
  ::uint32_t _internal_check_as_user() const;
  void _internal_set_check_as_user(::uint32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedField<::uint64_t> selected_cols_;
    mutable ::google::protobuf::internal::CachedSize _selected_cols_cached_byte_size_;
    ::google::protobuf::RepeatedField<::uint64_t> inserted_cols_;
    mutable ::google::protobuf::internal::CachedSize _inserted_cols_cached_byte_size_;
    ::google::protobuf::RepeatedField<::uint64_t> updated_cols_;
    mutable ::google::protobuf::internal::CachedSize _updated_cols_cached_byte_size_;
    ::uint32_t relid_;
    bool inh_;
    ::int64_t required_perms_;
    ::uint32_t check_as_user_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ParamRef final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ParamRef) */ {
 public:
  inline ParamRef() : ParamRef(nullptr) {}
  ~ParamRef() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ParamRef(::google::protobuf::internal::ConstantInitialized);

  inline ParamRef(const ParamRef& from)
      : ParamRef(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ParamRef& default_instance() {
    return *internal_default_instance();
  }
  static inline const ParamRef* internal_default_instance() {
    return reinterpret_cast<const ParamRef*>(
               &_ParamRef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    70;

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

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

  ParamRef* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ParamRef>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ParamRef& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ParamRef& from) {
    ParamRef::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ParamRef* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ParamRef";
  }
  protected:
  explicit ParamRef(::google::protobuf::Arena* arena);
  ParamRef(::google::protobuf::Arena* arena, const ParamRef& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kNumberFieldNumber = 1,
    kLocationFieldNumber = 2,
  };
  // int32 number = 1 [json_name = "number"];
  void clear_number() ;
  ::int32_t number() const;
  void set_number(::int32_t value);

  private:
  ::int32_t _internal_number() const;
  void _internal_set_number(::int32_t value);

  public:
  // int32 location = 2 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::int32_t number_;
    ::int32_t location_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class NotifyStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.NotifyStmt) */ {
 public:
  inline NotifyStmt() : NotifyStmt(nullptr) {}
  ~NotifyStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR NotifyStmt(::google::protobuf::internal::ConstantInitialized);

  inline NotifyStmt(const NotifyStmt& from)
      : NotifyStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NotifyStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const NotifyStmt* internal_default_instance() {
    return reinterpret_cast<const NotifyStmt*>(
               &_NotifyStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    211;

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

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

  NotifyStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NotifyStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const NotifyStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const NotifyStmt& from) {
    NotifyStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(NotifyStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.NotifyStmt";
  }
  protected:
  explicit NotifyStmt(::google::protobuf::Arena* arena);
  NotifyStmt(::google::protobuf::Arena* arena, const NotifyStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kConditionnameFieldNumber = 1,
    kPayloadFieldNumber = 2,
  };
  // string conditionname = 1 [json_name = "conditionname"];
  void clear_conditionname() ;
  const std::string& conditionname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_conditionname(Arg_&& arg, Args_... args);
  std::string* mutable_conditionname();
  PROTOBUF_NODISCARD std::string* release_conditionname();
  void set_allocated_conditionname(std::string* value);

  private:
  const std::string& _internal_conditionname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_payload(Arg_&& arg, Args_... args);
  std::string* mutable_payload();
  PROTOBUF_NODISCARD std::string* release_payload();
  void set_allocated_payload(std::string* value);

  private:
  const std::string& _internal_payload() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      48, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr conditionname_;
    ::google::protobuf::internal::ArenaStringPtr payload_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class LoadStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.LoadStmt) */ {
 public:
  inline LoadStmt() : LoadStmt(nullptr) {}
  ~LoadStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR LoadStmt(::google::protobuf::internal::ConstantInitialized);

  inline LoadStmt(const LoadStmt& from)
      : LoadStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LoadStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const LoadStmt* internal_default_instance() {
    return reinterpret_cast<const LoadStmt*>(
               &_LoadStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    220;

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

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

  LoadStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LoadStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const LoadStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const LoadStmt& from) {
    LoadStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(LoadStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.LoadStmt";
  }
  protected:
  explicit LoadStmt(::google::protobuf::Arena* arena);
  LoadStmt(::google::protobuf::Arena* arena, const LoadStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kFilenameFieldNumber = 1,
  };
  // string filename = 1 [json_name = "filename"];
  void clear_filename() ;
  const std::string& filename() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_filename(Arg_&& arg, Args_... args);
  std::string* mutable_filename();
  PROTOBUF_NODISCARD std::string* release_filename();
  void set_allocated_filename(std::string* value);

  private:
  const std::string& _internal_filename() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      34, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr filename_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ListenStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ListenStmt) */ {
 public:
  inline ListenStmt() : ListenStmt(nullptr) {}
  ~ListenStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ListenStmt(::google::protobuf::internal::ConstantInitialized);

  inline ListenStmt(const ListenStmt& from)
      : ListenStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ListenStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ListenStmt* internal_default_instance() {
    return reinterpret_cast<const ListenStmt*>(
               &_ListenStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    212;

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

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

  ListenStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ListenStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ListenStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ListenStmt& from) {
    ListenStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ListenStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ListenStmt";
  }
  protected:
  explicit ListenStmt(::google::protobuf::Arena* arena);
  ListenStmt(::google::protobuf::Arena* arena, const ListenStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kConditionnameFieldNumber = 1,
  };
  // string conditionname = 1 [json_name = "conditionname"];
  void clear_conditionname() ;
  const std::string& conditionname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_conditionname(Arg_&& arg, Args_... args);
  std::string* mutable_conditionname();
  PROTOBUF_NODISCARD std::string* release_conditionname();
  void set_allocated_conditionname(std::string* value);

  private:
  const std::string& _internal_conditionname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      41, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr conditionname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonFormat final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonFormat) */ {
 public:
  inline JsonFormat() : JsonFormat(nullptr) {}
  ~JsonFormat() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonFormat(::google::protobuf::internal::ConstantInitialized);

  inline JsonFormat(const JsonFormat& from)
      : JsonFormat(nullptr, from) {}
  JsonFormat(JsonFormat&& from) noexcept
    : JsonFormat() {
    *this = ::std::move(from);
  }

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

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonFormat& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonFormat* internal_default_instance() {
    return reinterpret_cast<const JsonFormat*>(
               &_JsonFormat_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    49;

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

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

  JsonFormat* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonFormat>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonFormat& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonFormat& from) {
    JsonFormat::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonFormat* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonFormat";
  }
  protected:
  explicit JsonFormat(::google::protobuf::Arena* arena);
  JsonFormat(::google::protobuf::Arena* arena, const JsonFormat& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kFormatTypeFieldNumber = 1,
    kEncodingFieldNumber = 2,
    kLocationFieldNumber = 3,
  };
  // .pg_query.JsonFormatType format_type = 1 [json_name = "format_type"];
  void clear_format_type() ;
  ::pg_query::JsonFormatType format_type() const;
  void set_format_type(::pg_query::JsonFormatType value);

  private:
  ::pg_query::JsonFormatType _internal_format_type() const;
  void _internal_set_format_type(::pg_query::JsonFormatType value);

  public:
  // .pg_query.JsonEncoding encoding = 2 [json_name = "encoding"];
  void clear_encoding() ;
  ::pg_query::JsonEncoding encoding() const;
  void set_encoding(::pg_query::JsonEncoding value);

  private:
  ::pg_query::JsonEncoding _internal_encoding() const;
  void _internal_set_encoding(::pg_query::JsonEncoding value);

  public:
  // int32 location = 3 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    int format_type_;
    int encoding_;
    ::int32_t location_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class Integer final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.Integer) */ {
 public:
  inline Integer() : Integer(nullptr) {}
  ~Integer() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Integer(::google::protobuf::internal::ConstantInitialized);

  inline Integer(const Integer& from)
      : Integer(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Integer& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Integer* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Integer* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Integer>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Integer& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const Integer& from) {
    Integer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(Integer* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.Integer";
  }
  protected:
  explicit Integer(::google::protobuf::Arena* arena);
  Integer(::google::protobuf::Arena* arena, const Integer& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kIvalFieldNumber = 1,
  };
  // int32 ival = 1;
  void clear_ival() ;
  ::int32_t ival() const;
  void set_ival(::int32_t value);

  private:
  ::int32_t _internal_ival() const;
  void _internal_set_ival(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::int32_t ival_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class InlineCodeBlock final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.InlineCodeBlock) */ {
 public:
  inline InlineCodeBlock() : InlineCodeBlock(nullptr) {}
  ~InlineCodeBlock() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR InlineCodeBlock(::google::protobuf::internal::ConstantInitialized);

  inline InlineCodeBlock(const InlineCodeBlock& from)
      : InlineCodeBlock(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const InlineCodeBlock& default_instance() {
    return *internal_default_instance();
  }
  static inline const InlineCodeBlock* internal_default_instance() {
    return reinterpret_cast<const InlineCodeBlock*>(
               &_InlineCodeBlock_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    201;

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

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

  InlineCodeBlock* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InlineCodeBlock>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const InlineCodeBlock& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const InlineCodeBlock& from) {
    InlineCodeBlock::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(InlineCodeBlock* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.InlineCodeBlock";
  }
  protected:
  explicit InlineCodeBlock(::google::protobuf::Arena* arena);
  InlineCodeBlock(::google::protobuf::Arena* arena, const InlineCodeBlock& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_source_text(Arg_&& arg, Args_... args);
  std::string* mutable_source_text();
  PROTOBUF_NODISCARD std::string* release_source_text();
  void set_allocated_source_text(std::string* value);

  private:
  const std::string& _internal_source_text() const;
  inline PROTOBUF_ALWAYS_INLINE 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() ;
  ::uint32_t lang_oid() const;
  void set_lang_oid(::uint32_t value);

  private:
  ::uint32_t _internal_lang_oid() const;
  void _internal_set_lang_oid(::uint32_t 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 0,
      44, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr source_text_;
    ::uint32_t lang_oid_;
    bool lang_is_trusted_;
    bool atomic_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class Float final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.Float) */ {
 public:
  inline Float() : Float(nullptr) {}
  ~Float() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Float(::google::protobuf::internal::ConstantInitialized);

  inline Float(const Float& from)
      : Float(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Float& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Float* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Float* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Float>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Float& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const Float& from) {
    Float::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(Float* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.Float";
  }
  protected:
  explicit Float(::google::protobuf::Arena* arena);
  Float(::google::protobuf::Arena* arena, const Float& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kFvalFieldNumber = 1,
  };
  // string fval = 1;
  void clear_fval() ;
  const std::string& fval() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_fval(Arg_&& arg, Args_... args);
  std::string* mutable_fval();
  PROTOBUF_NODISCARD std::string* release_fval();
  void set_allocated_fval(std::string* value);

  private:
  const std::string& _internal_fval() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fval(
      const std::string& value);
  std::string* _internal_mutable_fval();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      27, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr fval_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class FetchStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.FetchStmt) */ {
 public:
  inline FetchStmt() : FetchStmt(nullptr) {}
  ~FetchStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR FetchStmt(::google::protobuf::internal::ConstantInitialized);

  inline FetchStmt(const FetchStmt& from)
      : FetchStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FetchStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const FetchStmt* internal_default_instance() {
    return reinterpret_cast<const FetchStmt*>(
               &_FetchStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    192;

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

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

  FetchStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FetchStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const FetchStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const FetchStmt& from) {
    FetchStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(FetchStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.FetchStmt";
  }
  protected:
  explicit FetchStmt(::google::protobuf::Arena* arena);
  FetchStmt(::google::protobuf::Arena* arena, const FetchStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_portalname(Arg_&& arg, Args_... args);
  std::string* mutable_portalname();
  PROTOBUF_NODISCARD std::string* release_portalname();
  void set_allocated_portalname(std::string* value);

  private:
  const std::string& _internal_portalname() const;
  inline PROTOBUF_ALWAYS_INLINE 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() ;
  ::int64_t how_many() const;
  void set_how_many(::int64_t value);

  private:
  ::int64_t _internal_how_many() const;
  void _internal_set_how_many(::int64_t 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 0,
      37, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr portalname_;
    ::int64_t how_many_;
    int direction_;
    bool ismove_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DropTableSpaceStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DropTableSpaceStmt) */ {
 public:
  inline DropTableSpaceStmt() : DropTableSpaceStmt(nullptr) {}
  ~DropTableSpaceStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DropTableSpaceStmt(::google::protobuf::internal::ConstantInitialized);

  inline DropTableSpaceStmt(const DropTableSpaceStmt& from)
      : DropTableSpaceStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DropTableSpaceStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DropTableSpaceStmt* internal_default_instance() {
    return reinterpret_cast<const DropTableSpaceStmt*>(
               &_DropTableSpaceStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    152;

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

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

  DropTableSpaceStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DropTableSpaceStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DropTableSpaceStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DropTableSpaceStmt& from) {
    DropTableSpaceStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DropTableSpaceStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DropTableSpaceStmt";
  }
  protected:
  explicit DropTableSpaceStmt(::google::protobuf::Arena* arena);
  DropTableSpaceStmt(::google::protobuf::Arena* arena, const DropTableSpaceStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTablespacenameFieldNumber = 1,
    kMissingOkFieldNumber = 2,
  };
  // string tablespacename = 1 [json_name = "tablespacename"];
  void clear_tablespacename() ;
  const std::string& tablespacename() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_tablespacename(Arg_&& arg, Args_... args);
  std::string* mutable_tablespacename();
  PROTOBUF_NODISCARD std::string* release_tablespacename();
  void set_allocated_tablespacename(std::string* value);

  private:
  const std::string& _internal_tablespacename() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      50, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr tablespacename_;
    bool missing_ok_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DropSubscriptionStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DropSubscriptionStmt) */ {
 public:
  inline DropSubscriptionStmt() : DropSubscriptionStmt(nullptr) {}
  ~DropSubscriptionStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DropSubscriptionStmt(::google::protobuf::internal::ConstantInitialized);

  inline DropSubscriptionStmt(const DropSubscriptionStmt& from)
      : DropSubscriptionStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DropSubscriptionStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DropSubscriptionStmt* internal_default_instance() {
    return reinterpret_cast<const DropSubscriptionStmt*>(
               &_DropSubscriptionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    254;

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

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

  DropSubscriptionStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DropSubscriptionStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DropSubscriptionStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DropSubscriptionStmt& from) {
    DropSubscriptionStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DropSubscriptionStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DropSubscriptionStmt";
  }
  protected:
  explicit DropSubscriptionStmt(::google::protobuf::Arena* arena);
  DropSubscriptionStmt(::google::protobuf::Arena* arena, const DropSubscriptionStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_subname(Arg_&& arg, Args_... args);
  std::string* mutable_subname();
  PROTOBUF_NODISCARD std::string* release_subname();
  void set_allocated_subname(std::string* value);

  private:
  const std::string& _internal_subname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 0,
      45, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr subname_;
    bool missing_ok_;
    int behavior_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DiscardStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DiscardStmt) */ {
 public:
  inline DiscardStmt() : DiscardStmt(nullptr) {}
  ~DiscardStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DiscardStmt(::google::protobuf::internal::ConstantInitialized);

  inline DiscardStmt(const DiscardStmt& from)
      : DiscardStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DiscardStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DiscardStmt* internal_default_instance() {
    return reinterpret_cast<const DiscardStmt*>(
               &_DiscardStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    234;

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

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

  DiscardStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DiscardStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DiscardStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DiscardStmt& from) {
    DiscardStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DiscardStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DiscardStmt";
  }
  protected:
  explicit DiscardStmt(::google::protobuf::Arena* arena);
  DiscardStmt(::google::protobuf::Arena* arena, const DiscardStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    int target_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DeallocateStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DeallocateStmt) */ {
 public:
  inline DeallocateStmt() : DeallocateStmt(nullptr) {}
  ~DeallocateStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DeallocateStmt(::google::protobuf::internal::ConstantInitialized);

  inline DeallocateStmt(const DeallocateStmt& from)
      : DeallocateStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DeallocateStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DeallocateStmt* internal_default_instance() {
    return reinterpret_cast<const DeallocateStmt*>(
               &_DeallocateStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    243;

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

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

  DeallocateStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeallocateStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DeallocateStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DeallocateStmt& from) {
    DeallocateStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DeallocateStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DeallocateStmt";
  }
  protected:
  explicit DeallocateStmt(::google::protobuf::Arena* arena);
  DeallocateStmt(::google::protobuf::Arena* arena, const DeallocateStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kNameFieldNumber = 1,
  };
  // string name = 1 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      36, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr name_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ClosePortalStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ClosePortalStmt) */ {
 public:
  inline ClosePortalStmt() : ClosePortalStmt(nullptr) {}
  ~ClosePortalStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ClosePortalStmt(::google::protobuf::internal::ConstantInitialized);

  inline ClosePortalStmt(const ClosePortalStmt& from)
      : ClosePortalStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ClosePortalStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClosePortalStmt* internal_default_instance() {
    return reinterpret_cast<const ClosePortalStmt*>(
               &_ClosePortalStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    191;

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

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

  ClosePortalStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ClosePortalStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ClosePortalStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ClosePortalStmt& from) {
    ClosePortalStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ClosePortalStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ClosePortalStmt";
  }
  protected:
  explicit ClosePortalStmt(::google::protobuf::Arena* arena);
  ClosePortalStmt(::google::protobuf::Arena* arena, const ClosePortalStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kPortalnameFieldNumber = 1,
  };
  // string portalname = 1 [json_name = "portalname"];
  void clear_portalname() ;
  const std::string& portalname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_portalname(Arg_&& arg, Args_... args);
  std::string* mutable_portalname();
  PROTOBUF_NODISCARD std::string* release_portalname();
  void set_allocated_portalname(std::string* value);

  private:
  const std::string& _internal_portalname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      43, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr portalname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CheckPointStmt final :
    public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:pg_query.CheckPointStmt) */ {
 public:
  inline CheckPointStmt() : CheckPointStmt(nullptr) {}
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CheckPointStmt(::google::protobuf::internal::ConstantInitialized);

  inline CheckPointStmt(const CheckPointStmt& from)
      : CheckPointStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CheckPointStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CheckPointStmt* internal_default_instance() {
    return reinterpret_cast<const CheckPointStmt*>(
               &_CheckPointStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    233;

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

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

  CheckPointStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CheckPointStmt>(arena);
  }
  using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CheckPointStmt& from) {
    ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CheckPointStmt& from) {
    ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CheckPointStmt";
  }
  protected:
  explicit CheckPointStmt(::google::protobuf::Arena* arena);
  CheckPointStmt(::google::protobuf::Arena* arena, const CheckPointStmt& from);
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CallContext final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CallContext) */ {
 public:
  inline CallContext() : CallContext(nullptr) {}
  ~CallContext() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CallContext(::google::protobuf::internal::ConstantInitialized);

  inline CallContext(const CallContext& from)
      : CallContext(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CallContext& default_instance() {
    return *internal_default_instance();
  }
  static inline const CallContext* internal_default_instance() {
    return reinterpret_cast<const CallContext*>(
               &_CallContext_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    203;

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

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

  CallContext* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CallContext>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CallContext& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CallContext& from) {
    CallContext::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CallContext* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CallContext";
  }
  protected:
  explicit CallContext(::google::protobuf::Arena* arena);
  CallContext(::google::protobuf::Arena* arena, const CallContext& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    bool atomic_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class Boolean final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.Boolean) */ {
 public:
  inline Boolean() : Boolean(nullptr) {}
  ~Boolean() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Boolean(::google::protobuf::internal::ConstantInitialized);

  inline Boolean(const Boolean& from)
      : Boolean(nullptr, from) {}
  Boolean(Boolean&& from) noexcept
    : Boolean() {
    *this = ::std::move(from);
  }

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

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

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

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

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

  Boolean* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Boolean>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Boolean& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const Boolean& from) {
    Boolean::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(Boolean* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.Boolean";
  }
  protected:
  explicit Boolean(::google::protobuf::Arena* arena);
  Boolean(::google::protobuf::Arena* arena, const Boolean& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kBoolvalFieldNumber = 1,
  };
  // bool boolval = 1;
  void clear_boolval() ;
  bool boolval() const;
  void set_boolval(bool value);

  private:
  bool _internal_boolval() const;
  void _internal_set_boolval(bool value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    bool boolval_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class BitString final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.BitString) */ {
 public:
  inline BitString() : BitString(nullptr) {}
  ~BitString() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR BitString(::google::protobuf::internal::ConstantInitialized);

  inline BitString(const BitString& from)
      : BitString(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

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

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

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

  BitString* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BitString>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const BitString& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const BitString& from) {
    BitString::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(BitString* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.BitString";
  }
  protected:
  explicit BitString(::google::protobuf::Arena* arena);
  BitString(::google::protobuf::Arena* arena, const BitString& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kBsvalFieldNumber = 1,
  };
  // string bsval = 1;
  void clear_bsval() ;
  const std::string& bsval() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_bsval(Arg_&& arg, Args_... args);
  std::string* mutable_bsval();
  PROTOBUF_NODISCARD std::string* release_bsval();
  void set_allocated_bsval(std::string* value);

  private:
  const std::string& _internal_bsval() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bsval(
      const std::string& value);
  std::string* _internal_mutable_bsval();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      32, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr bsval_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterEventTrigStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterEventTrigStmt) */ {
 public:
  inline AlterEventTrigStmt() : AlterEventTrigStmt(nullptr) {}
  ~AlterEventTrigStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterEventTrigStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterEventTrigStmt(const AlterEventTrigStmt& from)
      : AlterEventTrigStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterEventTrigStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterEventTrigStmt* internal_default_instance() {
    return reinterpret_cast<const AlterEventTrigStmt*>(
               &_AlterEventTrigStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    172;

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

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

  AlterEventTrigStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterEventTrigStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterEventTrigStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterEventTrigStmt& from) {
    AlterEventTrigStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterEventTrigStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterEventTrigStmt";
  }
  protected:
  explicit AlterEventTrigStmt(::google::protobuf::Arena* arena);
  AlterEventTrigStmt(::google::protobuf::Arena* arena, const AlterEventTrigStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTrignameFieldNumber = 1,
    kTgenabledFieldNumber = 2,
  };
  // string trigname = 1 [json_name = "trigname"];
  void clear_trigname() ;
  const std::string& trigname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_trigname(Arg_&& arg, Args_... args);
  std::string* mutable_trigname();
  PROTOBUF_NODISCARD std::string* release_trigname();
  void set_allocated_trigname(std::string* value);

  private:
  const std::string& _internal_trigname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_tgenabled(Arg_&& arg, Args_... args);
  std::string* mutable_tgenabled();
  PROTOBUF_NODISCARD std::string* release_tgenabled();
  void set_allocated_tgenabled(std::string* value);

  private:
  const std::string& _internal_tgenabled() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      53, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr trigname_;
    ::google::protobuf::internal::ArenaStringPtr tgenabled_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterDatabaseRefreshCollStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDatabaseRefreshCollStmt) */ {
 public:
  inline AlterDatabaseRefreshCollStmt() : AlterDatabaseRefreshCollStmt(nullptr) {}
  ~AlterDatabaseRefreshCollStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterDatabaseRefreshCollStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterDatabaseRefreshCollStmt(const AlterDatabaseRefreshCollStmt& from)
      : AlterDatabaseRefreshCollStmt(nullptr, from) {}
  AlterDatabaseRefreshCollStmt(AlterDatabaseRefreshCollStmt&& from) noexcept
    : AlterDatabaseRefreshCollStmt() {
    *this = ::std::move(from);
  }

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

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterDatabaseRefreshCollStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterDatabaseRefreshCollStmt* internal_default_instance() {
    return reinterpret_cast<const AlterDatabaseRefreshCollStmt*>(
               &_AlterDatabaseRefreshCollStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    223;

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

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

  AlterDatabaseRefreshCollStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterDatabaseRefreshCollStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterDatabaseRefreshCollStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterDatabaseRefreshCollStmt& from) {
    AlterDatabaseRefreshCollStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterDatabaseRefreshCollStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterDatabaseRefreshCollStmt";
  }
  protected:
  explicit AlterDatabaseRefreshCollStmt(::google::protobuf::Arena* arena);
  AlterDatabaseRefreshCollStmt(::google::protobuf::Arena* arena, const AlterDatabaseRefreshCollStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDbnameFieldNumber = 1,
  };
  // string dbname = 1 [json_name = "dbname"];
  void clear_dbname() ;
  const std::string& dbname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_dbname(Arg_&& arg, Args_... args);
  std::string* mutable_dbname();
  PROTOBUF_NODISCARD std::string* release_dbname();
  void set_allocated_dbname(std::string* value);

  private:
  const std::string& _internal_dbname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dbname(
      const std::string& value);
  std::string* _internal_mutable_dbname();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      52, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr dbname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class A_Star final :
    public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:pg_query.A_Star) */ {
 public:
  inline A_Star() : A_Star(nullptr) {}
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR A_Star(::google::protobuf::internal::ConstantInitialized);

  inline A_Star(const A_Star& from)
      : A_Star(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const A_Star& default_instance() {
    return *internal_default_instance();
  }
  static inline const A_Star* internal_default_instance() {
    return reinterpret_cast<const A_Star*>(
               &_A_Star_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    76;

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

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

  A_Star* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<A_Star>(arena);
  }
  using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const A_Star& from) {
    ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const A_Star& from) {
    ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.A_Star";
  }
  protected:
  explicit A_Star(::google::protobuf::Arena* arena);
  A_Star(::google::protobuf::Arena* arena, const A_Star& from);
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ScanResult final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ScanResult) */ {
 public:
  inline ScanResult() : ScanResult(nullptr) {}
  ~ScanResult() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ScanResult(::google::protobuf::internal::ConstantInitialized);

  inline ScanResult(const ScanResult& from)
      : ScanResult(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ScanResult& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScanResult* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ScanResult* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ScanResult>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ScanResult& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ScanResult& from) {
    ScanResult::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ScanResult* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ScanResult";
  }
  protected:
  explicit ScanResult(::google::protobuf::Arena* arena);
  ScanResult(::google::protobuf::Arena* arena, const ScanResult& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::ScanToken >*
      mutable_tokens();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::ScanToken>& _internal_tokens() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::ScanToken>* _internal_mutable_tokens();
  public:
  const ::pg_query::ScanToken& tokens(int index) const;
  ::pg_query::ScanToken* add_tokens();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::ScanToken >&
      tokens() const;
  // int32 version = 1;
  void clear_version() ;
  ::int32_t version() const;
  void set_version(::int32_t value);

  private:
  ::int32_t _internal_version() const;
  void _internal_set_version(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::ScanToken > tokens_;
    ::int32_t version_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonReturning final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonReturning) */ {
 public:
  inline JsonReturning() : JsonReturning(nullptr) {}
  ~JsonReturning() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonReturning(::google::protobuf::internal::ConstantInitialized);

  inline JsonReturning(const JsonReturning& from)
      : JsonReturning(nullptr, from) {}
  JsonReturning(JsonReturning&& from) noexcept
    : JsonReturning() {
    *this = ::std::move(from);
  }

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

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonReturning& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonReturning* internal_default_instance() {
    return reinterpret_cast<const JsonReturning*>(
               &_JsonReturning_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    50;

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

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

  JsonReturning* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonReturning>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonReturning& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonReturning& from) {
    JsonReturning::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonReturning* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonReturning";
  }
  protected:
  explicit JsonReturning(::google::protobuf::Arena* arena);
  JsonReturning(::google::protobuf::Arena* arena, const JsonReturning& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kFormatFieldNumber = 1,
    kTypidFieldNumber = 2,
    kTypmodFieldNumber = 3,
  };
  // .pg_query.JsonFormat format = 1 [json_name = "format"];
  bool has_format() const;
  void clear_format() ;
  const ::pg_query::JsonFormat& format() const;
  PROTOBUF_NODISCARD ::pg_query::JsonFormat* release_format();
  ::pg_query::JsonFormat* mutable_format();
  void set_allocated_format(::pg_query::JsonFormat* value);
  void unsafe_arena_set_allocated_format(::pg_query::JsonFormat* value);
  ::pg_query::JsonFormat* unsafe_arena_release_format();

  private:
  const ::pg_query::JsonFormat& _internal_format() const;
  ::pg_query::JsonFormat* _internal_mutable_format();

  public:
  // uint32 typid = 2 [json_name = "typid"];
  void clear_typid() ;
  ::uint32_t typid() const;
  void set_typid(::uint32_t value);

  private:
  ::uint32_t _internal_typid() const;
  void _internal_set_typid(::uint32_t value);

  public:
  // int32 typmod = 3 [json_name = "typmod"];
  void clear_typmod() ;
  ::int32_t typmod() const;
  void set_typmod(::int32_t value);

  private:
  ::int32_t _internal_typmod() const;
  void _internal_set_typmod(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::JsonFormat* format_;
    ::uint32_t typid_;
    ::int32_t typmod_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DropUserMappingStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DropUserMappingStmt) */ {
 public:
  inline DropUserMappingStmt() : DropUserMappingStmt(nullptr) {}
  ~DropUserMappingStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DropUserMappingStmt(::google::protobuf::internal::ConstantInitialized);

  inline DropUserMappingStmt(const DropUserMappingStmt& from)
      : DropUserMappingStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DropUserMappingStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DropUserMappingStmt* internal_default_instance() {
    return reinterpret_cast<const DropUserMappingStmt*>(
               &_DropUserMappingStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    165;

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

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

  DropUserMappingStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DropUserMappingStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DropUserMappingStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DropUserMappingStmt& from) {
    DropUserMappingStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DropUserMappingStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DropUserMappingStmt";
  }
  protected:
  explicit DropUserMappingStmt(::google::protobuf::Arena* arena);
  DropUserMappingStmt(::google::protobuf::Arena* arena, const DropUserMappingStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_servername(Arg_&& arg, Args_... args);
  std::string* mutable_servername();
  PROTOBUF_NODISCARD std::string* release_servername();
  void set_allocated_servername(std::string* value);

  private:
  const std::string& _internal_servername() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_user() ;
  const ::pg_query::RoleSpec& user() const;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_user();
  ::pg_query::RoleSpec* mutable_user();
  void set_allocated_user(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_user(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_user();

  private:
  const ::pg_query::RoleSpec& _internal_user() const;
  ::pg_query::RoleSpec* _internal_mutable_user();

  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.DropUserMappingStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      47, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr servername_;
    ::pg_query::RoleSpec* user_;
    bool missing_ok_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class A_Const final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Const) */ {
 public:
  inline A_Const() : A_Const(nullptr) {}
  ~A_Const() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR A_Const(::google::protobuf::internal::ConstantInitialized);

  inline A_Const(const A_Const& from)
      : A_Const(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const A_Const& default_instance() {
    return *internal_default_instance();
  }
  enum ValCase {
    kIval = 1,
    kFval = 2,
    kBoolval = 3,
    kSval = 4,
    kBsval = 5,
    VAL_NOT_SET = 0,
  };

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

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

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

  A_Const* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<A_Const>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const A_Const& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const A_Const& from) {
    A_Const::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(A_Const* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.A_Const";
  }
  protected:
  explicit A_Const(::google::protobuf::Arena* arena);
  A_Const(::google::protobuf::Arena* arena, const A_Const& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kIsnullFieldNumber = 10,
    kLocationFieldNumber = 11,
    kIvalFieldNumber = 1,
    kFvalFieldNumber = 2,
    kBoolvalFieldNumber = 3,
    kSvalFieldNumber = 4,
    kBsvalFieldNumber = 5,
  };
  // bool isnull = 10;
  void clear_isnull() ;
  bool isnull() const;
  void set_isnull(bool value);

  private:
  bool _internal_isnull() const;
  void _internal_set_isnull(bool value);

  public:
  // int32 location = 11;
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // .pg_query.Integer ival = 1;
  bool has_ival() const;
  private:
  bool _internal_has_ival() const;

  public:
  void clear_ival() ;
  const ::pg_query::Integer& ival() const;
  PROTOBUF_NODISCARD ::pg_query::Integer* release_ival();
  ::pg_query::Integer* mutable_ival();
  void set_allocated_ival(::pg_query::Integer* value);
  void unsafe_arena_set_allocated_ival(::pg_query::Integer* value);
  ::pg_query::Integer* unsafe_arena_release_ival();

  private:
  const ::pg_query::Integer& _internal_ival() const;
  ::pg_query::Integer* _internal_mutable_ival();

  public:
  // .pg_query.Float fval = 2;
  bool has_fval() const;
  private:
  bool _internal_has_fval() const;

  public:
  void clear_fval() ;
  const ::pg_query::Float& fval() const;
  PROTOBUF_NODISCARD ::pg_query::Float* release_fval();
  ::pg_query::Float* mutable_fval();
  void set_allocated_fval(::pg_query::Float* value);
  void unsafe_arena_set_allocated_fval(::pg_query::Float* value);
  ::pg_query::Float* unsafe_arena_release_fval();

  private:
  const ::pg_query::Float& _internal_fval() const;
  ::pg_query::Float* _internal_mutable_fval();

  public:
  // .pg_query.Boolean boolval = 3;
  bool has_boolval() const;
  private:
  bool _internal_has_boolval() const;

  public:
  void clear_boolval() ;
  const ::pg_query::Boolean& boolval() const;
  PROTOBUF_NODISCARD ::pg_query::Boolean* release_boolval();
  ::pg_query::Boolean* mutable_boolval();
  void set_allocated_boolval(::pg_query::Boolean* value);
  void unsafe_arena_set_allocated_boolval(::pg_query::Boolean* value);
  ::pg_query::Boolean* unsafe_arena_release_boolval();

  private:
  const ::pg_query::Boolean& _internal_boolval() const;
  ::pg_query::Boolean* _internal_mutable_boolval();

  public:
  // .pg_query.String sval = 4;
  bool has_sval() const;
  private:
  bool _internal_has_sval() const;

  public:
  void clear_sval() ;
  const ::pg_query::String& sval() const;
  PROTOBUF_NODISCARD ::pg_query::String* release_sval();
  ::pg_query::String* mutable_sval();
  void set_allocated_sval(::pg_query::String* value);
  void unsafe_arena_set_allocated_sval(::pg_query::String* value);
  ::pg_query::String* unsafe_arena_release_sval();

  private:
  const ::pg_query::String& _internal_sval() const;
  ::pg_query::String* _internal_mutable_sval();

  public:
  // .pg_query.BitString bsval = 5;
  bool has_bsval() const;
  private:
  bool _internal_has_bsval() const;

  public:
  void clear_bsval() ;
  const ::pg_query::BitString& bsval() const;
  PROTOBUF_NODISCARD ::pg_query::BitString* release_bsval();
  ::pg_query::BitString* mutable_bsval();
  void set_allocated_bsval(::pg_query::BitString* value);
  void unsafe_arena_set_allocated_bsval(::pg_query::BitString* value);
  ::pg_query::BitString* unsafe_arena_release_bsval();

  private:
  const ::pg_query::BitString& _internal_bsval() const;
  ::pg_query::BitString* _internal_mutable_bsval();

  public:
  void clear_val();
  ValCase val_case() const;
  // @@protoc_insertion_point(class_scope:pg_query.A_Const)
 private:
  class _Internal;
  void set_has_ival();
  void set_has_fval();
  void set_has_boolval();
  void set_has_sval();
  void set_has_bsval();

  inline bool has_val() const;
  inline void clear_has_val();

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 7, 5,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    bool isnull_;
    ::int32_t location_;
    union ValUnion {
      constexpr ValUnion() : _constinit_{} {}
        ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::pg_query::Integer* ival_;
      ::pg_query::Float* fval_;
      ::pg_query::Boolean* boolval_;
      ::pg_query::String* sval_;
      ::pg_query::BitString* bsval_;
    } val_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class A_ArrayExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.A_ArrayExpr) */ {
 public:
  inline A_ArrayExpr() : A_ArrayExpr(nullptr) {}
  ~A_ArrayExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR A_ArrayExpr(::google::protobuf::internal::ConstantInitialized);

  inline A_ArrayExpr(const A_ArrayExpr& from)
      : A_ArrayExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const A_ArrayExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const A_ArrayExpr* internal_default_instance() {
    return reinterpret_cast<const A_ArrayExpr*>(
               &_A_ArrayExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    79;

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

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

  A_ArrayExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<A_ArrayExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const A_ArrayExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const A_ArrayExpr& from) {
    A_ArrayExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(A_ArrayExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.A_ArrayExpr";
  }
  protected:
  explicit A_ArrayExpr(::google::protobuf::Arena* arena);
  A_ArrayExpr(::google::protobuf::Arena* arena, const A_ArrayExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_elements();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_elements() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_elements();
  public:
  const ::pg_query::Node& elements(int index) const;
  ::pg_query::Node* add_elements();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      elements() const;
  // int32 location = 2 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > elements_;
    ::int32_t location_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class A_Expr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Expr) */ {
 public:
  inline A_Expr() : A_Expr(nullptr) {}
  ~A_Expr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR A_Expr(::google::protobuf::internal::ConstantInitialized);

  inline A_Expr(const A_Expr& from)
      : A_Expr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const A_Expr& default_instance() {
    return *internal_default_instance();
  }
  static inline const A_Expr* internal_default_instance() {
    return reinterpret_cast<const A_Expr*>(
               &_A_Expr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    71;

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

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

  A_Expr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<A_Expr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const A_Expr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const A_Expr& from) {
    A_Expr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(A_Expr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.A_Expr";
  }
  protected:
  explicit A_Expr(::google::protobuf::Arena* arena);
  A_Expr(::google::protobuf::Arena* arena, const A_Expr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_name();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_name() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_name();
  public:
  const ::pg_query::Node& name(int index) const;
  ::pg_query::Node* add_name();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      name() const;
  // .pg_query.Node lexpr = 3 [json_name = "lexpr"];
  bool has_lexpr() const;
  void clear_lexpr() ;
  const ::pg_query::Node& lexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_lexpr();
  ::pg_query::Node* mutable_lexpr();
  void set_allocated_lexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_lexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_lexpr();

  private:
  const ::pg_query::Node& _internal_lexpr() const;
  ::pg_query::Node* _internal_mutable_lexpr();

  public:
  // .pg_query.Node rexpr = 4 [json_name = "rexpr"];
  bool has_rexpr() const;
  void clear_rexpr() ;
  const ::pg_query::Node& rexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_rexpr();
  ::pg_query::Node* mutable_rexpr();
  void set_allocated_rexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_rexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_rexpr();

  private:
  const ::pg_query::Node& _internal_rexpr() const;
  ::pg_query::Node* _internal_mutable_rexpr();

  public:
  // .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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > name_;
    ::pg_query::Node* lexpr_;
    ::pg_query::Node* rexpr_;
    int kind_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class A_Indices final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Indices) */ {
 public:
  inline A_Indices() : A_Indices(nullptr) {}
  ~A_Indices() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR A_Indices(::google::protobuf::internal::ConstantInitialized);

  inline A_Indices(const A_Indices& from)
      : A_Indices(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const A_Indices& default_instance() {
    return *internal_default_instance();
  }
  static inline const A_Indices* internal_default_instance() {
    return reinterpret_cast<const A_Indices*>(
               &_A_Indices_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    77;

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

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

  A_Indices* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<A_Indices>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const A_Indices& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const A_Indices& from) {
    A_Indices::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(A_Indices* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.A_Indices";
  }
  protected:
  explicit A_Indices(::google::protobuf::Arena* arena);
  A_Indices(::google::protobuf::Arena* arena, const A_Indices& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kLidxFieldNumber = 2,
    kUidxFieldNumber = 3,
    kIsSliceFieldNumber = 1,
  };
  // .pg_query.Node lidx = 2 [json_name = "lidx"];
  bool has_lidx() const;
  void clear_lidx() ;
  const ::pg_query::Node& lidx() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_lidx();
  ::pg_query::Node* mutable_lidx();
  void set_allocated_lidx(::pg_query::Node* value);
  void unsafe_arena_set_allocated_lidx(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_lidx();

  private:
  const ::pg_query::Node& _internal_lidx() const;
  ::pg_query::Node* _internal_mutable_lidx();

  public:
  // .pg_query.Node uidx = 3 [json_name = "uidx"];
  bool has_uidx() const;
  void clear_uidx() ;
  const ::pg_query::Node& uidx() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_uidx();
  ::pg_query::Node* mutable_uidx();
  void set_allocated_uidx(::pg_query::Node* value);
  void unsafe_arena_set_allocated_uidx(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_uidx();

  private:
  const ::pg_query::Node& _internal_uidx() const;
  ::pg_query::Node* _internal_mutable_uidx();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* lidx_;
    ::pg_query::Node* uidx_;
    bool is_slice_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class A_Indirection final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Indirection) */ {
 public:
  inline A_Indirection() : A_Indirection(nullptr) {}
  ~A_Indirection() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR A_Indirection(::google::protobuf::internal::ConstantInitialized);

  inline A_Indirection(const A_Indirection& from)
      : A_Indirection(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const A_Indirection& default_instance() {
    return *internal_default_instance();
  }
  static inline const A_Indirection* internal_default_instance() {
    return reinterpret_cast<const A_Indirection*>(
               &_A_Indirection_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    78;

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

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

  A_Indirection* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<A_Indirection>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const A_Indirection& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const A_Indirection& from) {
    A_Indirection::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(A_Indirection* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.A_Indirection";
  }
  protected:
  explicit A_Indirection(::google::protobuf::Arena* arena);
  A_Indirection(::google::protobuf::Arena* arena, const A_Indirection& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_indirection();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_indirection() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_indirection();
  public:
  const ::pg_query::Node& indirection(int index) const;
  ::pg_query::Node* add_indirection();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      indirection() const;
  // .pg_query.Node arg = 1 [json_name = "arg"];
  bool has_arg() const;
  void clear_arg() ;
  const ::pg_query::Node& arg() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* value);
  void unsafe_arena_set_allocated_arg(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_arg();

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > indirection_;
    ::pg_query::Node* arg_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AccessPriv final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AccessPriv) */ {
 public:
  inline AccessPriv() : AccessPriv(nullptr) {}
  ~AccessPriv() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AccessPriv(::google::protobuf::internal::ConstantInitialized);

  inline AccessPriv(const AccessPriv& from)
      : AccessPriv(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AccessPriv& default_instance() {
    return *internal_default_instance();
  }
  static inline const AccessPriv* internal_default_instance() {
    return reinterpret_cast<const AccessPriv*>(
               &_AccessPriv_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    143;

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

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

  AccessPriv* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AccessPriv>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AccessPriv& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AccessPriv& from) {
    AccessPriv::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AccessPriv* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AccessPriv";
  }
  protected:
  explicit AccessPriv(::google::protobuf::Arena* arena);
  AccessPriv(::google::protobuf::Arena* arena, const AccessPriv& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_cols();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_cols() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_cols();
  public:
  const ::pg_query::Node& cols(int index) const;
  ::pg_query::Node* add_cols();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      cols() const;
  // string priv_name = 1 [json_name = "priv_name"];
  void clear_priv_name() ;
  const std::string& priv_name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_priv_name(Arg_&& arg, Args_... args);
  std::string* mutable_priv_name();
  PROTOBUF_NODISCARD std::string* release_priv_name();
  void set_allocated_priv_name(std::string* value);

  private:
  const std::string& _internal_priv_name() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      37, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > cols_;
    ::google::protobuf::internal::ArenaStringPtr priv_name_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class Aggref final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.Aggref) */ {
 public:
  inline Aggref() : Aggref(nullptr) {}
  ~Aggref() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Aggref(::google::protobuf::internal::ConstantInitialized);

  inline Aggref(const Aggref& from)
      : Aggref(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Aggref& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Aggref* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Aggref* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Aggref>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Aggref& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const Aggref& from) {
    Aggref::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(Aggref* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.Aggref";
  }
  protected:
  explicit Aggref(::google::protobuf::Arena* arena);
  Aggref(::google::protobuf::Arena* arena, const Aggref& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kAggargtypesFieldNumber = 6,
    kAggdirectargsFieldNumber = 7,
    kArgsFieldNumber = 8,
    kAggorderFieldNumber = 9,
    kAggdistinctFieldNumber = 10,
    kAggkindFieldNumber = 14,
    kXprFieldNumber = 1,
    kAggfilterFieldNumber = 11,
    kAggfnoidFieldNumber = 2,
    kAggtypeFieldNumber = 3,
    kAggcollidFieldNumber = 4,
    kInputcollidFieldNumber = 5,
    kAggstarFieldNumber = 12,
    kAggvariadicFieldNumber = 13,
    kAgglevelsupFieldNumber = 15,
    kAggsplitFieldNumber = 16,
    kAggnoFieldNumber = 17,
    kAggtransnoFieldNumber = 18,
    kLocationFieldNumber = 19,
  };
  // repeated .pg_query.Node aggargtypes = 6 [json_name = "aggargtypes"];
  int aggargtypes_size() const;
  private:
  int _internal_aggargtypes_size() const;

  public:
  void clear_aggargtypes() ;
  ::pg_query::Node* mutable_aggargtypes(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_aggargtypes();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_aggargtypes() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_aggargtypes();
  public:
  const ::pg_query::Node& aggargtypes(int index) const;
  ::pg_query::Node* add_aggargtypes();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      aggargtypes() const;
  // repeated .pg_query.Node aggdirectargs = 7 [json_name = "aggdirectargs"];
  int aggdirectargs_size() const;
  private:
  int _internal_aggdirectargs_size() const;

  public:
  void clear_aggdirectargs() ;
  ::pg_query::Node* mutable_aggdirectargs(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_aggdirectargs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_aggdirectargs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_aggdirectargs();
  public:
  const ::pg_query::Node& aggdirectargs(int index) const;
  ::pg_query::Node* add_aggdirectargs();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      aggdirectargs() const;
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // repeated .pg_query.Node aggorder = 9 [json_name = "aggorder"];
  int aggorder_size() const;
  private:
  int _internal_aggorder_size() const;

  public:
  void clear_aggorder() ;
  ::pg_query::Node* mutable_aggorder(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_aggorder();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_aggorder() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_aggorder();
  public:
  const ::pg_query::Node& aggorder(int index) const;
  ::pg_query::Node* add_aggorder();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      aggorder() const;
  // repeated .pg_query.Node aggdistinct = 10 [json_name = "aggdistinct"];
  int aggdistinct_size() const;
  private:
  int _internal_aggdistinct_size() const;

  public:
  void clear_aggdistinct() ;
  ::pg_query::Node* mutable_aggdistinct(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_aggdistinct();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_aggdistinct() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_aggdistinct();
  public:
  const ::pg_query::Node& aggdistinct(int index) const;
  ::pg_query::Node* add_aggdistinct();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      aggdistinct() const;
  // string aggkind = 14 [json_name = "aggkind"];
  void clear_aggkind() ;
  const std::string& aggkind() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_aggkind(Arg_&& arg, Args_... args);
  std::string* mutable_aggkind();
  PROTOBUF_NODISCARD std::string* release_aggkind();
  void set_allocated_aggkind(std::string* value);

  private:
  const std::string& _internal_aggkind() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node aggfilter = 11 [json_name = "aggfilter"];
  bool has_aggfilter() const;
  void clear_aggfilter() ;
  const ::pg_query::Node& aggfilter() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_aggfilter();
  ::pg_query::Node* mutable_aggfilter();
  void set_allocated_aggfilter(::pg_query::Node* value);
  void unsafe_arena_set_allocated_aggfilter(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_aggfilter();

  private:
  const ::pg_query::Node& _internal_aggfilter() const;
  ::pg_query::Node* _internal_mutable_aggfilter();

  public:
  // uint32 aggfnoid = 2 [json_name = "aggfnoid"];
  void clear_aggfnoid() ;
  ::uint32_t aggfnoid() const;
  void set_aggfnoid(::uint32_t value);

  private:
  ::uint32_t _internal_aggfnoid() const;
  void _internal_set_aggfnoid(::uint32_t value);

  public:
  // uint32 aggtype = 3 [json_name = "aggtype"];
  void clear_aggtype() ;
  ::uint32_t aggtype() const;
  void set_aggtype(::uint32_t value);

  private:
  ::uint32_t _internal_aggtype() const;
  void _internal_set_aggtype(::uint32_t value);

  public:
  // uint32 aggcollid = 4 [json_name = "aggcollid"];
  void clear_aggcollid() ;
  ::uint32_t aggcollid() const;
  void set_aggcollid(::uint32_t value);

  private:
  ::uint32_t _internal_aggcollid() const;
  void _internal_set_aggcollid(::uint32_t value);

  public:
  // uint32 inputcollid = 5 [json_name = "inputcollid"];
  void clear_inputcollid() ;
  ::uint32_t inputcollid() const;
  void set_inputcollid(::uint32_t value);

  private:
  ::uint32_t _internal_inputcollid() const;
  void _internal_set_inputcollid(::uint32_t value);

  public:
  // bool aggstar = 12 [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 = 13 [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 = 15 [json_name = "agglevelsup"];
  void clear_agglevelsup() ;
  ::uint32_t agglevelsup() const;
  void set_agglevelsup(::uint32_t value);

  private:
  ::uint32_t _internal_agglevelsup() const;
  void _internal_set_agglevelsup(::uint32_t value);

  public:
  // .pg_query.AggSplit aggsplit = 16 [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 aggno = 17 [json_name = "aggno"];
  void clear_aggno() ;
  ::int32_t aggno() const;
  void set_aggno(::int32_t value);

  private:
  ::int32_t _internal_aggno() const;
  void _internal_set_aggno(::int32_t value);

  public:
  // int32 aggtransno = 18 [json_name = "aggtransno"];
  void clear_aggtransno() ;
  ::int32_t aggtransno() const;
  void set_aggtransno(::int32_t value);

  private:
  ::int32_t _internal_aggtransno() const;
  void _internal_set_aggtransno(::int32_t value);

  public:
  // int32 location = 19 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      5, 19, 7,
      47, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > aggargtypes_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > aggdirectargs_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > aggorder_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > aggdistinct_;
    ::google::protobuf::internal::ArenaStringPtr aggkind_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* aggfilter_;
    ::uint32_t aggfnoid_;
    ::uint32_t aggtype_;
    ::uint32_t aggcollid_;
    ::uint32_t inputcollid_;
    bool aggstar_;
    bool aggvariadic_;
    ::uint32_t agglevelsup_;
    int aggsplit_;
    ::int32_t aggno_;
    ::int32_t aggtransno_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class Alias final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.Alias) */ {
 public:
  inline Alias() : Alias(nullptr) {}
  ~Alias() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Alias(::google::protobuf::internal::ConstantInitialized);

  inline Alias(const Alias& from)
      : Alias(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Alias& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Alias* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Alias* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Alias>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Alias& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const Alias& from) {
    Alias::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(Alias* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.Alias";
  }
  protected:
  explicit Alias(::google::protobuf::Arena* arena);
  Alias(::google::protobuf::Arena* arena, const Alias& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_colnames();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_colnames() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_colnames();
  public:
  const ::pg_query::Node& colnames(int index) const;
  ::pg_query::Node* add_colnames();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      colnames() const;
  // string aliasname = 1 [json_name = "aliasname"];
  void clear_aliasname() ;
  const std::string& aliasname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_aliasname(Arg_&& arg, Args_... args);
  std::string* mutable_aliasname();
  PROTOBUF_NODISCARD std::string* release_aliasname();
  void set_allocated_aliasname(std::string* value);

  private:
  const std::string& _internal_aliasname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      32, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > colnames_;
    ::google::protobuf::internal::ArenaStringPtr aliasname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterCollationStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterCollationStmt) */ {
 public:
  inline AlterCollationStmt() : AlterCollationStmt(nullptr) {}
  ~AlterCollationStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterCollationStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterCollationStmt(const AlterCollationStmt& from)
      : AlterCollationStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterCollationStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterCollationStmt* internal_default_instance() {
    return reinterpret_cast<const AlterCollationStmt*>(
               &_AlterCollationStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    139;

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

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

  AlterCollationStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterCollationStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterCollationStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterCollationStmt& from) {
    AlterCollationStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterCollationStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterCollationStmt";
  }
  protected:
  explicit AlterCollationStmt(::google::protobuf::Arena* arena);
  AlterCollationStmt(::google::protobuf::Arena* arena, const AlterCollationStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_collname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_collname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_collname();
  public:
  const ::pg_query::Node& collname(int index) const;
  ::pg_query::Node* add_collname();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      collname() const;
  // @@protoc_insertion_point(class_scope:pg_query.AlterCollationStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > collname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterDatabaseSetStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDatabaseSetStmt) */ {
 public:
  inline AlterDatabaseSetStmt() : AlterDatabaseSetStmt(nullptr) {}
  ~AlterDatabaseSetStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterDatabaseSetStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterDatabaseSetStmt(const AlterDatabaseSetStmt& from)
      : AlterDatabaseSetStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterDatabaseSetStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterDatabaseSetStmt* internal_default_instance() {
    return reinterpret_cast<const AlterDatabaseSetStmt*>(
               &_AlterDatabaseSetStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    224;

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

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

  AlterDatabaseSetStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterDatabaseSetStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterDatabaseSetStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterDatabaseSetStmt& from) {
    AlterDatabaseSetStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterDatabaseSetStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterDatabaseSetStmt";
  }
  protected:
  explicit AlterDatabaseSetStmt(::google::protobuf::Arena* arena);
  AlterDatabaseSetStmt(::google::protobuf::Arena* arena, const AlterDatabaseSetStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDbnameFieldNumber = 1,
    kSetstmtFieldNumber = 2,
  };
  // string dbname = 1 [json_name = "dbname"];
  void clear_dbname() ;
  const std::string& dbname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_dbname(Arg_&& arg, Args_... args);
  std::string* mutable_dbname();
  PROTOBUF_NODISCARD std::string* release_dbname();
  void set_allocated_dbname(std::string* value);

  private:
  const std::string& _internal_dbname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_setstmt() ;
  const ::pg_query::VariableSetStmt& setstmt() const;
  PROTOBUF_NODISCARD ::pg_query::VariableSetStmt* release_setstmt();
  ::pg_query::VariableSetStmt* mutable_setstmt();
  void set_allocated_setstmt(::pg_query::VariableSetStmt* value);
  void unsafe_arena_set_allocated_setstmt(::pg_query::VariableSetStmt* value);
  ::pg_query::VariableSetStmt* unsafe_arena_release_setstmt();

  private:
  const ::pg_query::VariableSetStmt& _internal_setstmt() const;
  ::pg_query::VariableSetStmt* _internal_mutable_setstmt();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      44, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr dbname_;
    ::pg_query::VariableSetStmt* setstmt_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterDatabaseStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDatabaseStmt) */ {
 public:
  inline AlterDatabaseStmt() : AlterDatabaseStmt(nullptr) {}
  ~AlterDatabaseStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterDatabaseStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterDatabaseStmt(const AlterDatabaseStmt& from)
      : AlterDatabaseStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterDatabaseStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterDatabaseStmt* internal_default_instance() {
    return reinterpret_cast<const AlterDatabaseStmt*>(
               &_AlterDatabaseStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    222;

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

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

  AlterDatabaseStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterDatabaseStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterDatabaseStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterDatabaseStmt& from) {
    AlterDatabaseStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterDatabaseStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterDatabaseStmt";
  }
  protected:
  explicit AlterDatabaseStmt(::google::protobuf::Arena* arena);
  AlterDatabaseStmt(::google::protobuf::Arena* arena, const AlterDatabaseStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string dbname = 1 [json_name = "dbname"];
  void clear_dbname() ;
  const std::string& dbname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_dbname(Arg_&& arg, Args_... args);
  std::string* mutable_dbname();
  PROTOBUF_NODISCARD std::string* release_dbname();
  void set_allocated_dbname(std::string* value);

  private:
  const std::string& _internal_dbname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      41, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr dbname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterDefaultPrivilegesStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDefaultPrivilegesStmt) */ {
 public:
  inline AlterDefaultPrivilegesStmt() : AlterDefaultPrivilegesStmt(nullptr) {}
  ~AlterDefaultPrivilegesStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterDefaultPrivilegesStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt& from)
      : AlterDefaultPrivilegesStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterDefaultPrivilegesStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterDefaultPrivilegesStmt* internal_default_instance() {
    return reinterpret_cast<const AlterDefaultPrivilegesStmt*>(
               &_AlterDefaultPrivilegesStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    145;

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

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

  AlterDefaultPrivilegesStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterDefaultPrivilegesStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterDefaultPrivilegesStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterDefaultPrivilegesStmt& from) {
    AlterDefaultPrivilegesStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterDefaultPrivilegesStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterDefaultPrivilegesStmt";
  }
  protected:
  explicit AlterDefaultPrivilegesStmt(::google::protobuf::Arena* arena);
  AlterDefaultPrivilegesStmt(::google::protobuf::Arena* arena, const AlterDefaultPrivilegesStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // .pg_query.GrantStmt action = 2 [json_name = "action"];
  bool has_action() const;
  void clear_action() ;
  const ::pg_query::GrantStmt& action() const;
  PROTOBUF_NODISCARD ::pg_query::GrantStmt* release_action();
  ::pg_query::GrantStmt* mutable_action();
  void set_allocated_action(::pg_query::GrantStmt* value);
  void unsafe_arena_set_allocated_action(::pg_query::GrantStmt* value);
  ::pg_query::GrantStmt* unsafe_arena_release_action();

  private:
  const ::pg_query::GrantStmt& _internal_action() const;
  ::pg_query::GrantStmt* _internal_mutable_action();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::pg_query::GrantStmt* action_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterDomainStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDomainStmt) */ {
 public:
  inline AlterDomainStmt() : AlterDomainStmt(nullptr) {}
  ~AlterDomainStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterDomainStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterDomainStmt(const AlterDomainStmt& from)
      : AlterDomainStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterDomainStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterDomainStmt* internal_default_instance() {
    return reinterpret_cast<const AlterDomainStmt*>(
               &_AlterDomainStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    140;

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

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

  AlterDomainStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterDomainStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterDomainStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterDomainStmt& from) {
    AlterDomainStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterDomainStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterDomainStmt";
  }
  protected:
  explicit AlterDomainStmt(::google::protobuf::Arena* arena);
  AlterDomainStmt(::google::protobuf::Arena* arena, const AlterDomainStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_type_name();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_type_name() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_type_name();
  public:
  const ::pg_query::Node& type_name(int index) const;
  ::pg_query::Node* add_type_name();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      type_name() const;
  // string subtype = 1 [json_name = "subtype"];
  void clear_subtype() ;
  const std::string& subtype() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_subtype(Arg_&& arg, Args_... args);
  std::string* mutable_subtype();
  PROTOBUF_NODISCARD std::string* release_subtype();
  void set_allocated_subtype(std::string* value);

  private:
  const std::string& _internal_subtype() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .pg_query.Node def = 4 [json_name = "def"];
  bool has_def() const;
  void clear_def() ;
  const ::pg_query::Node& def() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_def();
  ::pg_query::Node* mutable_def();
  void set_allocated_def(::pg_query::Node* value);
  void unsafe_arena_set_allocated_def(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_def();

  private:
  const ::pg_query::Node& _internal_def() const;
  ::pg_query::Node* _internal_mutable_def();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 2,
      44, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > type_name_;
    ::google::protobuf::internal::ArenaStringPtr subtype_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::pg_query::Node* def_;
    int behavior_;
    bool missing_ok_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterEnumStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterEnumStmt) */ {
 public:
  inline AlterEnumStmt() : AlterEnumStmt(nullptr) {}
  ~AlterEnumStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterEnumStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterEnumStmt(const AlterEnumStmt& from)
      : AlterEnumStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterEnumStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterEnumStmt* internal_default_instance() {
    return reinterpret_cast<const AlterEnumStmt*>(
               &_AlterEnumStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    218;

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

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

  AlterEnumStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterEnumStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterEnumStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterEnumStmt& from) {
    AlterEnumStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterEnumStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterEnumStmt";
  }
  protected:
  explicit AlterEnumStmt(::google::protobuf::Arena* arena);
  AlterEnumStmt(::google::protobuf::Arena* arena, const AlterEnumStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_type_name();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_type_name() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_type_name();
  public:
  const ::pg_query::Node& type_name(int index) const;
  ::pg_query::Node* add_type_name();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      type_name() const;
  // string old_val = 2 [json_name = "oldVal"];
  void clear_old_val() ;
  const std::string& old_val() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_old_val(Arg_&& arg, Args_... args);
  std::string* mutable_old_val();
  PROTOBUF_NODISCARD std::string* release_old_val();
  void set_allocated_old_val(std::string* value);

  private:
  const std::string& _internal_old_val() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_new_val(Arg_&& arg, Args_... args);
  std::string* mutable_new_val();
  PROTOBUF_NODISCARD std::string* release_new_val();
  void set_allocated_new_val(std::string* value);

  private:
  const std::string& _internal_new_val() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_new_val_neighbor(Arg_&& arg, Args_... args);
  std::string* mutable_new_val_neighbor();
  PROTOBUF_NODISCARD std::string* release_new_val_neighbor();
  void set_allocated_new_val_neighbor(std::string* value);

  private:
  const std::string& _internal_new_val_neighbor() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 1,
      61, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > type_name_;
    ::google::protobuf::internal::ArenaStringPtr old_val_;
    ::google::protobuf::internal::ArenaStringPtr new_val_;
    ::google::protobuf::internal::ArenaStringPtr new_val_neighbor_;
    bool new_val_is_after_;
    bool skip_if_new_val_exists_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterExtensionContentsStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterExtensionContentsStmt) */ {
 public:
  inline AlterExtensionContentsStmt() : AlterExtensionContentsStmt(nullptr) {}
  ~AlterExtensionContentsStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterExtensionContentsStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterExtensionContentsStmt(const AlterExtensionContentsStmt& from)
      : AlterExtensionContentsStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterExtensionContentsStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterExtensionContentsStmt* internal_default_instance() {
    return reinterpret_cast<const AlterExtensionContentsStmt*>(
               &_AlterExtensionContentsStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    157;

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

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

  AlterExtensionContentsStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterExtensionContentsStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterExtensionContentsStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterExtensionContentsStmt& from) {
    AlterExtensionContentsStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterExtensionContentsStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterExtensionContentsStmt";
  }
  protected:
  explicit AlterExtensionContentsStmt(::google::protobuf::Arena* arena);
  AlterExtensionContentsStmt(::google::protobuf::Arena* arena, const AlterExtensionContentsStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_extname(Arg_&& arg, Args_... args);
  std::string* mutable_extname();
  PROTOBUF_NODISCARD std::string* release_extname();
  void set_allocated_extname(std::string* value);

  private:
  const std::string& _internal_extname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_object() ;
  const ::pg_query::Node& object() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* value);
  void unsafe_arena_set_allocated_object(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_object();

  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();

  public:
  // int32 action = 2 [json_name = "action"];
  void clear_action() ;
  ::int32_t action() const;
  void set_action(::int32_t value);

  private:
  ::int32_t _internal_action() const;
  void _internal_set_action(::int32_t 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 1,
      51, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr extname_;
    ::pg_query::Node* object_;
    ::int32_t action_;
    int objtype_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterExtensionStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterExtensionStmt) */ {
 public:
  inline AlterExtensionStmt() : AlterExtensionStmt(nullptr) {}
  ~AlterExtensionStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterExtensionStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterExtensionStmt(const AlterExtensionStmt& from)
      : AlterExtensionStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterExtensionStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterExtensionStmt* internal_default_instance() {
    return reinterpret_cast<const AlterExtensionStmt*>(
               &_AlterExtensionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    156;

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

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

  AlterExtensionStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterExtensionStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterExtensionStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterExtensionStmt& from) {
    AlterExtensionStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterExtensionStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterExtensionStmt";
  }
  protected:
  explicit AlterExtensionStmt(::google::protobuf::Arena* arena);
  AlterExtensionStmt(::google::protobuf::Arena* arena, const AlterExtensionStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string extname = 1 [json_name = "extname"];
  void clear_extname() ;
  const std::string& extname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_extname(Arg_&& arg, Args_... args);
  std::string* mutable_extname();
  PROTOBUF_NODISCARD std::string* release_extname();
  void set_allocated_extname(std::string* value);

  private:
  const std::string& _internal_extname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      43, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr extname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterFdwStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterFdwStmt) */ {
 public:
  inline AlterFdwStmt() : AlterFdwStmt(nullptr) {}
  ~AlterFdwStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterFdwStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterFdwStmt(const AlterFdwStmt& from)
      : AlterFdwStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterFdwStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterFdwStmt* internal_default_instance() {
    return reinterpret_cast<const AlterFdwStmt*>(
               &_AlterFdwStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    159;

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

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

  AlterFdwStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterFdwStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterFdwStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterFdwStmt& from) {
    AlterFdwStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterFdwStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterFdwStmt";
  }
  protected:
  explicit AlterFdwStmt(::google::protobuf::Arena* arena);
  AlterFdwStmt(::google::protobuf::Arena* arena, const AlterFdwStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_func_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_func_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_func_options();
  public:
  const ::pg_query::Node& func_options(int index) const;
  ::pg_query::Node* add_func_options();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string fdwname = 1 [json_name = "fdwname"];
  void clear_fdwname() ;
  const std::string& fdwname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_fdwname(Arg_&& arg, Args_... args);
  std::string* mutable_fdwname();
  PROTOBUF_NODISCARD std::string* release_fdwname();
  void set_allocated_fdwname(std::string* value);

  private:
  const std::string& _internal_fdwname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      37, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > func_options_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr fdwname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterForeignServerStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterForeignServerStmt) */ {
 public:
  inline AlterForeignServerStmt() : AlterForeignServerStmt(nullptr) {}
  ~AlterForeignServerStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterForeignServerStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterForeignServerStmt(const AlterForeignServerStmt& from)
      : AlterForeignServerStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterForeignServerStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterForeignServerStmt* internal_default_instance() {
    return reinterpret_cast<const AlterForeignServerStmt*>(
               &_AlterForeignServerStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    161;

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

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

  AlterForeignServerStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterForeignServerStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterForeignServerStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterForeignServerStmt& from) {
    AlterForeignServerStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterForeignServerStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterForeignServerStmt";
  }
  protected:
  explicit AlterForeignServerStmt(::google::protobuf::Arena* arena);
  AlterForeignServerStmt(::google::protobuf::Arena* arena, const AlterForeignServerStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string servername = 1 [json_name = "servername"];
  void clear_servername() ;
  const std::string& servername() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_servername(Arg_&& arg, Args_... args);
  std::string* mutable_servername();
  PROTOBUF_NODISCARD std::string* release_servername();
  void set_allocated_servername(std::string* value);

  private:
  const std::string& _internal_servername() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_version(Arg_&& arg, Args_... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* value);

  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 1,
      57, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr servername_;
    ::google::protobuf::internal::ArenaStringPtr version_;
    bool has_version_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterFunctionStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterFunctionStmt) */ {
 public:
  inline AlterFunctionStmt() : AlterFunctionStmt(nullptr) {}
  ~AlterFunctionStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterFunctionStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterFunctionStmt(const AlterFunctionStmt& from)
      : AlterFunctionStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterFunctionStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterFunctionStmt* internal_default_instance() {
    return reinterpret_cast<const AlterFunctionStmt*>(
               &_AlterFunctionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    199;

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

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

  AlterFunctionStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterFunctionStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterFunctionStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterFunctionStmt& from) {
    AlterFunctionStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterFunctionStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterFunctionStmt";
  }
  protected:
  explicit AlterFunctionStmt(::google::protobuf::Arena* arena);
  AlterFunctionStmt(::google::protobuf::Arena* arena, const AlterFunctionStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_actions();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_actions() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_actions();
  public:
  const ::pg_query::Node& actions(int index) const;
  ::pg_query::Node* add_actions();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      actions() const;
  // .pg_query.ObjectWithArgs func = 2 [json_name = "func"];
  bool has_func() const;
  void clear_func() ;
  const ::pg_query::ObjectWithArgs& func() const;
  PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_func();
  ::pg_query::ObjectWithArgs* mutable_func();
  void set_allocated_func(::pg_query::ObjectWithArgs* value);
  void unsafe_arena_set_allocated_func(::pg_query::ObjectWithArgs* value);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_func();

  private:
  const ::pg_query::ObjectWithArgs& _internal_func() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_func();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > actions_;
    ::pg_query::ObjectWithArgs* func_;
    int objtype_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterObjectDependsStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterObjectDependsStmt) */ {
 public:
  inline AlterObjectDependsStmt() : AlterObjectDependsStmt(nullptr) {}
  ~AlterObjectDependsStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterObjectDependsStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterObjectDependsStmt(const AlterObjectDependsStmt& from)
      : AlterObjectDependsStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterObjectDependsStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterObjectDependsStmt* internal_default_instance() {
    return reinterpret_cast<const AlterObjectDependsStmt*>(
               &_AlterObjectDependsStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    205;

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

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

  AlterObjectDependsStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterObjectDependsStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterObjectDependsStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterObjectDependsStmt& from) {
    AlterObjectDependsStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterObjectDependsStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterObjectDependsStmt";
  }
  protected:
  explicit AlterObjectDependsStmt(::google::protobuf::Arena* arena);
  AlterObjectDependsStmt(::google::protobuf::Arena* arena, const AlterObjectDependsStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node object = 3 [json_name = "object"];
  bool has_object() const;
  void clear_object() ;
  const ::pg_query::Node& object() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* value);
  void unsafe_arena_set_allocated_object(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_object();

  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();

  public:
  // .pg_query.String extname = 4 [json_name = "extname"];
  bool has_extname() const;
  void clear_extname() ;
  const ::pg_query::String& extname() const;
  PROTOBUF_NODISCARD ::pg_query::String* release_extname();
  ::pg_query::String* mutable_extname();
  void set_allocated_extname(::pg_query::String* value);
  void unsafe_arena_set_allocated_extname(::pg_query::String* value);
  ::pg_query::String* unsafe_arena_release_extname();

  private:
  const ::pg_query::String& _internal_extname() const;
  ::pg_query::String* _internal_mutable_extname();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::RangeVar* relation_;
    ::pg_query::Node* object_;
    ::pg_query::String* extname_;
    int object_type_;
    bool remove_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterObjectSchemaStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterObjectSchemaStmt) */ {
 public:
  inline AlterObjectSchemaStmt() : AlterObjectSchemaStmt(nullptr) {}
  ~AlterObjectSchemaStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterObjectSchemaStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterObjectSchemaStmt(const AlterObjectSchemaStmt& from)
      : AlterObjectSchemaStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterObjectSchemaStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterObjectSchemaStmt* internal_default_instance() {
    return reinterpret_cast<const AlterObjectSchemaStmt*>(
               &_AlterObjectSchemaStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    206;

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

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

  AlterObjectSchemaStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterObjectSchemaStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterObjectSchemaStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterObjectSchemaStmt& from) {
    AlterObjectSchemaStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterObjectSchemaStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterObjectSchemaStmt";
  }
  protected:
  explicit AlterObjectSchemaStmt(::google::protobuf::Arena* arena);
  AlterObjectSchemaStmt(::google::protobuf::Arena* arena, const AlterObjectSchemaStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_newschema(Arg_&& arg, Args_... args);
  std::string* mutable_newschema();
  PROTOBUF_NODISCARD std::string* release_newschema();
  void set_allocated_newschema(std::string* value);

  private:
  const std::string& _internal_newschema() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node object = 3 [json_name = "object"];
  bool has_object() const;
  void clear_object() ;
  const ::pg_query::Node& object() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* value);
  void unsafe_arena_set_allocated_object(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_object();

  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      48, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr newschema_;
    ::pg_query::RangeVar* relation_;
    ::pg_query::Node* object_;
    int object_type_;
    bool missing_ok_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterOpFamilyStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterOpFamilyStmt) */ {
 public:
  inline AlterOpFamilyStmt() : AlterOpFamilyStmt(nullptr) {}
  ~AlterOpFamilyStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterOpFamilyStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterOpFamilyStmt(const AlterOpFamilyStmt& from)
      : AlterOpFamilyStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterOpFamilyStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterOpFamilyStmt* internal_default_instance() {
    return reinterpret_cast<const AlterOpFamilyStmt*>(
               &_AlterOpFamilyStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    185;

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

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

  AlterOpFamilyStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterOpFamilyStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterOpFamilyStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterOpFamilyStmt& from) {
    AlterOpFamilyStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterOpFamilyStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterOpFamilyStmt";
  }
  protected:
  explicit AlterOpFamilyStmt(::google::protobuf::Arena* arena);
  AlterOpFamilyStmt(::google::protobuf::Arena* arena, const AlterOpFamilyStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_opfamilyname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_opfamilyname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_opfamilyname();
  public:
  const ::pg_query::Node& opfamilyname(int index) const;
  ::pg_query::Node* add_opfamilyname();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_items();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_items() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_items();
  public:
  const ::pg_query::Node& items(int index) const;
  ::pg_query::Node* add_items();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      items() const;
  // string amname = 2 [json_name = "amname"];
  void clear_amname() ;
  const std::string& amname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_amname(Arg_&& arg, Args_... args);
  std::string* mutable_amname();
  PROTOBUF_NODISCARD std::string* release_amname();
  void set_allocated_amname(std::string* value);

  private:
  const std::string& _internal_amname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      41, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > opfamilyname_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > items_;
    ::google::protobuf::internal::ArenaStringPtr amname_;
    bool is_drop_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterOperatorStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterOperatorStmt) */ {
 public:
  inline AlterOperatorStmt() : AlterOperatorStmt(nullptr) {}
  ~AlterOperatorStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterOperatorStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterOperatorStmt(const AlterOperatorStmt& from)
      : AlterOperatorStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterOperatorStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterOperatorStmt* internal_default_instance() {
    return reinterpret_cast<const AlterOperatorStmt*>(
               &_AlterOperatorStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    208;

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

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

  AlterOperatorStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterOperatorStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterOperatorStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterOperatorStmt& from) {
    AlterOperatorStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterOperatorStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterOperatorStmt";
  }
  protected:
  explicit AlterOperatorStmt(::google::protobuf::Arena* arena);
  AlterOperatorStmt(::google::protobuf::Arena* arena, const AlterOperatorStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // .pg_query.ObjectWithArgs opername = 1 [json_name = "opername"];
  bool has_opername() const;
  void clear_opername() ;
  const ::pg_query::ObjectWithArgs& opername() const;
  PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_opername();
  ::pg_query::ObjectWithArgs* mutable_opername();
  void set_allocated_opername(::pg_query::ObjectWithArgs* value);
  void unsafe_arena_set_allocated_opername(::pg_query::ObjectWithArgs* value);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_opername();

  private:
  const ::pg_query::ObjectWithArgs& _internal_opername() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_opername();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::pg_query::ObjectWithArgs* opername_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterOwnerStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterOwnerStmt) */ {
 public:
  inline AlterOwnerStmt() : AlterOwnerStmt(nullptr) {}
  ~AlterOwnerStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterOwnerStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterOwnerStmt(const AlterOwnerStmt& from)
      : AlterOwnerStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterOwnerStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterOwnerStmt* internal_default_instance() {
    return reinterpret_cast<const AlterOwnerStmt*>(
               &_AlterOwnerStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    207;

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

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

  AlterOwnerStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterOwnerStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterOwnerStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterOwnerStmt& from) {
    AlterOwnerStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterOwnerStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterOwnerStmt";
  }
  protected:
  explicit AlterOwnerStmt(::google::protobuf::Arena* arena);
  AlterOwnerStmt(::google::protobuf::Arena* arena, const AlterOwnerStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node object = 3 [json_name = "object"];
  bool has_object() const;
  void clear_object() ;
  const ::pg_query::Node& object() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* value);
  void unsafe_arena_set_allocated_object(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_object();

  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();

  public:
  // .pg_query.RoleSpec newowner = 4 [json_name = "newowner"];
  bool has_newowner() const;
  void clear_newowner() ;
  const ::pg_query::RoleSpec& newowner() const;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_newowner();
  ::pg_query::RoleSpec* mutable_newowner();
  void set_allocated_newowner(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_newowner(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_newowner();

  private:
  const ::pg_query::RoleSpec& _internal_newowner() const;
  ::pg_query::RoleSpec* _internal_mutable_newowner();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::RangeVar* relation_;
    ::pg_query::Node* object_;
    ::pg_query::RoleSpec* newowner_;
    int object_type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterPolicyStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterPolicyStmt) */ {
 public:
  inline AlterPolicyStmt() : AlterPolicyStmt(nullptr) {}
  ~AlterPolicyStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterPolicyStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterPolicyStmt(const AlterPolicyStmt& from)
      : AlterPolicyStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterPolicyStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterPolicyStmt* internal_default_instance() {
    return reinterpret_cast<const AlterPolicyStmt*>(
               &_AlterPolicyStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    168;

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

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

  AlterPolicyStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterPolicyStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterPolicyStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterPolicyStmt& from) {
    AlterPolicyStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterPolicyStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterPolicyStmt";
  }
  protected:
  explicit AlterPolicyStmt(::google::protobuf::Arena* arena);
  AlterPolicyStmt(::google::protobuf::Arena* arena, const AlterPolicyStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_roles();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_roles() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_roles();
  public:
  const ::pg_query::Node& roles(int index) const;
  ::pg_query::Node* add_roles();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      roles() const;
  // string policy_name = 1 [json_name = "policy_name"];
  void clear_policy_name() ;
  const std::string& policy_name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_policy_name(Arg_&& arg, Args_... args);
  std::string* mutable_policy_name();
  PROTOBUF_NODISCARD std::string* release_policy_name();
  void set_allocated_policy_name(std::string* value);

  private:
  const std::string& _internal_policy_name() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_table() ;
  const ::pg_query::RangeVar& table() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_table();
  ::pg_query::RangeVar* mutable_table();
  void set_allocated_table(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_table(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_table();

  private:
  const ::pg_query::RangeVar& _internal_table() const;
  ::pg_query::RangeVar* _internal_mutable_table();

  public:
  // .pg_query.Node qual = 4 [json_name = "qual"];
  bool has_qual() const;
  void clear_qual() ;
  const ::pg_query::Node& qual() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_qual();
  ::pg_query::Node* mutable_qual();
  void set_allocated_qual(::pg_query::Node* value);
  void unsafe_arena_set_allocated_qual(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_qual();

  private:
  const ::pg_query::Node& _internal_qual() const;
  ::pg_query::Node* _internal_mutable_qual();

  public:
  // .pg_query.Node with_check = 5 [json_name = "with_check"];
  bool has_with_check() const;
  void clear_with_check() ;
  const ::pg_query::Node& with_check() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_with_check();
  ::pg_query::Node* mutable_with_check();
  void set_allocated_with_check(::pg_query::Node* value);
  void unsafe_arena_set_allocated_with_check(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_with_check();

  private:
  const ::pg_query::Node& _internal_with_check() const;
  ::pg_query::Node* _internal_mutable_with_check();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 4,
      44, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > roles_;
    ::google::protobuf::internal::ArenaStringPtr policy_name_;
    ::pg_query::RangeVar* table_;
    ::pg_query::Node* qual_;
    ::pg_query::Node* with_check_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterPublicationStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterPublicationStmt) */ {
 public:
  inline AlterPublicationStmt() : AlterPublicationStmt(nullptr) {}
  ~AlterPublicationStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterPublicationStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterPublicationStmt(const AlterPublicationStmt& from)
      : AlterPublicationStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterPublicationStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterPublicationStmt* internal_default_instance() {
    return reinterpret_cast<const AlterPublicationStmt*>(
               &_AlterPublicationStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    251;

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

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

  AlterPublicationStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterPublicationStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterPublicationStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterPublicationStmt& from) {
    AlterPublicationStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterPublicationStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterPublicationStmt";
  }
  protected:
  explicit AlterPublicationStmt(::google::protobuf::Arena* arena);
  AlterPublicationStmt(::google::protobuf::Arena* arena, const AlterPublicationStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kOptionsFieldNumber = 2,
    kPubobjectsFieldNumber = 3,
    kPubnameFieldNumber = 1,
    kForAllTablesFieldNumber = 4,
    kActionFieldNumber = 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // repeated .pg_query.Node pubobjects = 3 [json_name = "pubobjects"];
  int pubobjects_size() const;
  private:
  int _internal_pubobjects_size() const;

  public:
  void clear_pubobjects() ;
  ::pg_query::Node* mutable_pubobjects(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_pubobjects();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_pubobjects() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_pubobjects();
  public:
  const ::pg_query::Node& pubobjects(int index) const;
  ::pg_query::Node* add_pubobjects();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      pubobjects() const;
  // string pubname = 1 [json_name = "pubname"];
  void clear_pubname() ;
  const std::string& pubname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_pubname(Arg_&& arg, Args_... args);
  std::string* mutable_pubname();
  PROTOBUF_NODISCARD std::string* release_pubname();
  void set_allocated_pubname(std::string* value);

  private:
  const std::string& _internal_pubname() const;
  inline PROTOBUF_ALWAYS_INLINE 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.AlterPublicationAction action = 5 [json_name = "action"];
  void clear_action() ;
  ::pg_query::AlterPublicationAction action() const;
  void set_action(::pg_query::AlterPublicationAction value);

  private:
  ::pg_query::AlterPublicationAction _internal_action() const;
  void _internal_set_action(::pg_query::AlterPublicationAction value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      45, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > pubobjects_;
    ::google::protobuf::internal::ArenaStringPtr pubname_;
    bool for_all_tables_;
    int action_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterRoleSetStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterRoleSetStmt) */ {
 public:
  inline AlterRoleSetStmt() : AlterRoleSetStmt(nullptr) {}
  ~AlterRoleSetStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterRoleSetStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterRoleSetStmt(const AlterRoleSetStmt& from)
      : AlterRoleSetStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterRoleSetStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterRoleSetStmt* internal_default_instance() {
    return reinterpret_cast<const AlterRoleSetStmt*>(
               &_AlterRoleSetStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    176;

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

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

  AlterRoleSetStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterRoleSetStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterRoleSetStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterRoleSetStmt& from) {
    AlterRoleSetStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterRoleSetStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterRoleSetStmt";
  }
  protected:
  explicit AlterRoleSetStmt(::google::protobuf::Arena* arena);
  AlterRoleSetStmt(::google::protobuf::Arena* arena, const AlterRoleSetStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_database(Arg_&& arg, Args_... args);
  std::string* mutable_database();
  PROTOBUF_NODISCARD std::string* release_database();
  void set_allocated_database(std::string* value);

  private:
  const std::string& _internal_database() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_role() ;
  const ::pg_query::RoleSpec& role() const;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_role();
  ::pg_query::RoleSpec* mutable_role();
  void set_allocated_role(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_role(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_role();

  private:
  const ::pg_query::RoleSpec& _internal_role() const;
  ::pg_query::RoleSpec* _internal_mutable_role();

  public:
  // .pg_query.VariableSetStmt setstmt = 3 [json_name = "setstmt"];
  bool has_setstmt() const;
  void clear_setstmt() ;
  const ::pg_query::VariableSetStmt& setstmt() const;
  PROTOBUF_NODISCARD ::pg_query::VariableSetStmt* release_setstmt();
  ::pg_query::VariableSetStmt* mutable_setstmt();
  void set_allocated_setstmt(::pg_query::VariableSetStmt* value);
  void unsafe_arena_set_allocated_setstmt(::pg_query::VariableSetStmt* value);
  ::pg_query::VariableSetStmt* unsafe_arena_release_setstmt();

  private:
  const ::pg_query::VariableSetStmt& _internal_setstmt() const;
  ::pg_query::VariableSetStmt* _internal_mutable_setstmt();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      42, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr database_;
    ::pg_query::RoleSpec* role_;
    ::pg_query::VariableSetStmt* setstmt_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterRoleStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterRoleStmt) */ {
 public:
  inline AlterRoleStmt() : AlterRoleStmt(nullptr) {}
  ~AlterRoleStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterRoleStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterRoleStmt(const AlterRoleStmt& from)
      : AlterRoleStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterRoleStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterRoleStmt* internal_default_instance() {
    return reinterpret_cast<const AlterRoleStmt*>(
               &_AlterRoleStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    175;

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

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

  AlterRoleStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterRoleStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterRoleStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterRoleStmt& from) {
    AlterRoleStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterRoleStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterRoleStmt";
  }
  protected:
  explicit AlterRoleStmt(::google::protobuf::Arena* arena);
  AlterRoleStmt(::google::protobuf::Arena* arena, const AlterRoleStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // .pg_query.RoleSpec role = 1 [json_name = "role"];
  bool has_role() const;
  void clear_role() ;
  const ::pg_query::RoleSpec& role() const;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_role();
  ::pg_query::RoleSpec* mutable_role();
  void set_allocated_role(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_role(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_role();

  private:
  const ::pg_query::RoleSpec& _internal_role() const;
  ::pg_query::RoleSpec* _internal_mutable_role();

  public:
  // int32 action = 3 [json_name = "action"];
  void clear_action() ;
  ::int32_t action() const;
  void set_action(::int32_t value);

  private:
  ::int32_t _internal_action() const;
  void _internal_set_action(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::pg_query::RoleSpec* role_;
    ::int32_t action_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterSeqStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterSeqStmt) */ {
 public:
  inline AlterSeqStmt() : AlterSeqStmt(nullptr) {}
  ~AlterSeqStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterSeqStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterSeqStmt(const AlterSeqStmt& from)
      : AlterSeqStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterSeqStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterSeqStmt* internal_default_instance() {
    return reinterpret_cast<const AlterSeqStmt*>(
               &_AlterSeqStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    179;

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

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

  AlterSeqStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterSeqStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterSeqStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterSeqStmt& from) {
    AlterSeqStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterSeqStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterSeqStmt";
  }
  protected:
  explicit AlterSeqStmt(::google::protobuf::Arena* arena);
  AlterSeqStmt(::google::protobuf::Arena* arena, const AlterSeqStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // .pg_query.RangeVar sequence = 1 [json_name = "sequence"];
  bool has_sequence() const;
  void clear_sequence() ;
  const ::pg_query::RangeVar& sequence() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_sequence();
  ::pg_query::RangeVar* mutable_sequence();
  void set_allocated_sequence(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_sequence(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_sequence();

  private:
  const ::pg_query::RangeVar& _internal_sequence() const;
  ::pg_query::RangeVar* _internal_mutable_sequence();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::pg_query::RangeVar* sequence_;
    bool for_identity_;
    bool missing_ok_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterStatsStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterStatsStmt) */ {
 public:
  inline AlterStatsStmt() : AlterStatsStmt(nullptr) {}
  ~AlterStatsStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterStatsStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterStatsStmt(const AlterStatsStmt& from)
      : AlterStatsStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterStatsStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterStatsStmt* internal_default_instance() {
    return reinterpret_cast<const AlterStatsStmt*>(
               &_AlterStatsStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    196;

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

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

  AlterStatsStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterStatsStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterStatsStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterStatsStmt& from) {
    AlterStatsStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterStatsStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterStatsStmt";
  }
  protected:
  explicit AlterStatsStmt(::google::protobuf::Arena* arena);
  AlterStatsStmt(::google::protobuf::Arena* arena, const AlterStatsStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_defnames();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_defnames() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_defnames();
  public:
  const ::pg_query::Node& defnames(int index) const;
  ::pg_query::Node* add_defnames();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      defnames() const;
  // int32 stxstattarget = 2 [json_name = "stxstattarget"];
  void clear_stxstattarget() ;
  ::int32_t stxstattarget() const;
  void set_stxstattarget(::int32_t value);

  private:
  ::int32_t _internal_stxstattarget() const;
  void _internal_set_stxstattarget(::int32_t 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > defnames_;
    ::int32_t stxstattarget_;
    bool missing_ok_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterSubscriptionStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterSubscriptionStmt) */ {
 public:
  inline AlterSubscriptionStmt() : AlterSubscriptionStmt(nullptr) {}
  ~AlterSubscriptionStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterSubscriptionStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterSubscriptionStmt(const AlterSubscriptionStmt& from)
      : AlterSubscriptionStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterSubscriptionStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterSubscriptionStmt* internal_default_instance() {
    return reinterpret_cast<const AlterSubscriptionStmt*>(
               &_AlterSubscriptionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    253;

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

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

  AlterSubscriptionStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterSubscriptionStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterSubscriptionStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterSubscriptionStmt& from) {
    AlterSubscriptionStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterSubscriptionStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterSubscriptionStmt";
  }
  protected:
  explicit AlterSubscriptionStmt(::google::protobuf::Arena* arena);
  AlterSubscriptionStmt(::google::protobuf::Arena* arena, const AlterSubscriptionStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_publication();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_publication() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_publication();
  public:
  const ::pg_query::Node& publication(int index) const;
  ::pg_query::Node* add_publication();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string subname = 2 [json_name = "subname"];
  void clear_subname() ;
  const std::string& subname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_subname(Arg_&& arg, Args_... args);
  std::string* mutable_subname();
  PROTOBUF_NODISCARD std::string* release_subname();
  void set_allocated_subname(std::string* value);

  private:
  const std::string& _internal_subname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_conninfo(Arg_&& arg, Args_... args);
  std::string* mutable_conninfo();
  PROTOBUF_NODISCARD std::string* release_conninfo();
  void set_allocated_conninfo(std::string* value);

  private:
  const std::string& _internal_conninfo() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      54, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > publication_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr subname_;
    ::google::protobuf::internal::ArenaStringPtr conninfo_;
    int kind_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterSystemStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterSystemStmt) */ {
 public:
  inline AlterSystemStmt() : AlterSystemStmt(nullptr) {}
  ~AlterSystemStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterSystemStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterSystemStmt(const AlterSystemStmt& from)
      : AlterSystemStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterSystemStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterSystemStmt* internal_default_instance() {
    return reinterpret_cast<const AlterSystemStmt*>(
               &_AlterSystemStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    226;

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

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

  AlterSystemStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterSystemStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterSystemStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterSystemStmt& from) {
    AlterSystemStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterSystemStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterSystemStmt";
  }
  protected:
  explicit AlterSystemStmt(::google::protobuf::Arena* arena);
  AlterSystemStmt(::google::protobuf::Arena* arena, const AlterSystemStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSetstmtFieldNumber = 1,
  };
  // .pg_query.VariableSetStmt setstmt = 1 [json_name = "setstmt"];
  bool has_setstmt() const;
  void clear_setstmt() ;
  const ::pg_query::VariableSetStmt& setstmt() const;
  PROTOBUF_NODISCARD ::pg_query::VariableSetStmt* release_setstmt();
  ::pg_query::VariableSetStmt* mutable_setstmt();
  void set_allocated_setstmt(::pg_query::VariableSetStmt* value);
  void unsafe_arena_set_allocated_setstmt(::pg_query::VariableSetStmt* value);
  ::pg_query::VariableSetStmt* unsafe_arena_release_setstmt();

  private:
  const ::pg_query::VariableSetStmt& _internal_setstmt() const;
  ::pg_query::VariableSetStmt* _internal_mutable_setstmt();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::VariableSetStmt* setstmt_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterTSConfigurationStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTSConfigurationStmt) */ {
 public:
  inline AlterTSConfigurationStmt() : AlterTSConfigurationStmt(nullptr) {}
  ~AlterTSConfigurationStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterTSConfigurationStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterTSConfigurationStmt(const AlterTSConfigurationStmt& from)
      : AlterTSConfigurationStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterTSConfigurationStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterTSConfigurationStmt* internal_default_instance() {
    return reinterpret_cast<const AlterTSConfigurationStmt*>(
               &_AlterTSConfigurationStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    247;

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

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

  AlterTSConfigurationStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterTSConfigurationStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterTSConfigurationStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterTSConfigurationStmt& from) {
    AlterTSConfigurationStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterTSConfigurationStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterTSConfigurationStmt";
  }
  protected:
  explicit AlterTSConfigurationStmt(::google::protobuf::Arena* arena);
  AlterTSConfigurationStmt(::google::protobuf::Arena* arena, const AlterTSConfigurationStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_cfgname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_cfgname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_cfgname();
  public:
  const ::pg_query::Node& cfgname(int index) const;
  ::pg_query::Node* add_cfgname();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_tokentype();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_tokentype() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_tokentype();
  public:
  const ::pg_query::Node& tokentype(int index) const;
  ::pg_query::Node* add_tokentype();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_dicts();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_dicts() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_dicts();
  public:
  const ::pg_query::Node& dicts(int index) const;
  ::pg_query::Node* add_dicts();
  const ::google::protobuf::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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > cfgname_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > tokentype_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > dicts_;
    int kind_;
    bool override_;
    bool replace_;
    bool missing_ok_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterTSDictionaryStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTSDictionaryStmt) */ {
 public:
  inline AlterTSDictionaryStmt() : AlterTSDictionaryStmt(nullptr) {}
  ~AlterTSDictionaryStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterTSDictionaryStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterTSDictionaryStmt(const AlterTSDictionaryStmt& from)
      : AlterTSDictionaryStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterTSDictionaryStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterTSDictionaryStmt* internal_default_instance() {
    return reinterpret_cast<const AlterTSDictionaryStmt*>(
               &_AlterTSDictionaryStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    246;

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

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

  AlterTSDictionaryStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterTSDictionaryStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterTSDictionaryStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterTSDictionaryStmt& from) {
    AlterTSDictionaryStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterTSDictionaryStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterTSDictionaryStmt";
  }
  protected:
  explicit AlterTSDictionaryStmt(::google::protobuf::Arena* arena);
  AlterTSDictionaryStmt(::google::protobuf::Arena* arena, const AlterTSDictionaryStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_dictname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_dictname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_dictname();
  public:
  const ::pg_query::Node& dictname(int index) const;
  ::pg_query::Node* add_dictname();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // @@protoc_insertion_point(class_scope:pg_query.AlterTSDictionaryStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > dictname_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterTableCmd final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTableCmd) */ {
 public:
  inline AlterTableCmd() : AlterTableCmd(nullptr) {}
  ~AlterTableCmd() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterTableCmd(::google::protobuf::internal::ConstantInitialized);

  inline AlterTableCmd(const AlterTableCmd& from)
      : AlterTableCmd(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterTableCmd& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterTableCmd* internal_default_instance() {
    return reinterpret_cast<const AlterTableCmd*>(
               &_AlterTableCmd_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    138;

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

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

  AlterTableCmd* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterTableCmd>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterTableCmd& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterTableCmd& from) {
    AlterTableCmd::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterTableCmd* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterTableCmd";
  }
  protected:
  explicit AlterTableCmd(::google::protobuf::Arena* arena);
  AlterTableCmd(::google::protobuf::Arena* arena, const AlterTableCmd& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kNameFieldNumber = 2,
    kNewownerFieldNumber = 4,
    kDefFieldNumber = 5,
    kSubtypeFieldNumber = 1,
    kNumFieldNumber = 3,
    kBehaviorFieldNumber = 6,
    kMissingOkFieldNumber = 7,
    kRecurseFieldNumber = 8,
  };
  // string name = 2 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .pg_query.RoleSpec newowner = 4 [json_name = "newowner"];
  bool has_newowner() const;
  void clear_newowner() ;
  const ::pg_query::RoleSpec& newowner() const;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_newowner();
  ::pg_query::RoleSpec* mutable_newowner();
  void set_allocated_newowner(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_newowner(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_newowner();

  private:
  const ::pg_query::RoleSpec& _internal_newowner() const;
  ::pg_query::RoleSpec* _internal_mutable_newowner();

  public:
  // .pg_query.Node def = 5 [json_name = "def"];
  bool has_def() const;
  void clear_def() ;
  const ::pg_query::Node& def() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_def();
  ::pg_query::Node* mutable_def();
  void set_allocated_def(::pg_query::Node* value);
  void unsafe_arena_set_allocated_def(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_def();

  private:
  const ::pg_query::Node& _internal_def() const;
  ::pg_query::Node* _internal_mutable_def();

  public:
  // .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() ;
  ::int32_t num() const;
  void set_num(::int32_t value);

  private:
  ::int32_t _internal_num() const;
  void _internal_set_num(::int32_t 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:
  // bool recurse = 8 [json_name = "recurse"];
  void clear_recurse() ;
  bool recurse() const;
  void set_recurse(bool value);

  private:
  bool _internal_recurse() const;
  void _internal_set_recurse(bool value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 2,
      43, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::pg_query::RoleSpec* newowner_;
    ::pg_query::Node* def_;
    int subtype_;
    ::int32_t num_;
    int behavior_;
    bool missing_ok_;
    bool recurse_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterTableMoveAllStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTableMoveAllStmt) */ {
 public:
  inline AlterTableMoveAllStmt() : AlterTableMoveAllStmt(nullptr) {}
  ~AlterTableMoveAllStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterTableMoveAllStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterTableMoveAllStmt(const AlterTableMoveAllStmt& from)
      : AlterTableMoveAllStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterTableMoveAllStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterTableMoveAllStmt* internal_default_instance() {
    return reinterpret_cast<const AlterTableMoveAllStmt*>(
               &_AlterTableMoveAllStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    154;

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

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

  AlterTableMoveAllStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterTableMoveAllStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterTableMoveAllStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterTableMoveAllStmt& from) {
    AlterTableMoveAllStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterTableMoveAllStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterTableMoveAllStmt";
  }
  protected:
  explicit AlterTableMoveAllStmt(::google::protobuf::Arena* arena);
  AlterTableMoveAllStmt(::google::protobuf::Arena* arena, const AlterTableMoveAllStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_roles();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_roles() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_roles();
  public:
  const ::pg_query::Node& roles(int index) const;
  ::pg_query::Node* add_roles();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      roles() const;
  // string orig_tablespacename = 1 [json_name = "orig_tablespacename"];
  void clear_orig_tablespacename() ;
  const std::string& orig_tablespacename() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_orig_tablespacename(Arg_&& arg, Args_... args);
  std::string* mutable_orig_tablespacename();
  PROTOBUF_NODISCARD std::string* release_orig_tablespacename();
  void set_allocated_orig_tablespacename(std::string* value);

  private:
  const std::string& _internal_orig_tablespacename() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_new_tablespacename(Arg_&& arg, Args_... args);
  std::string* mutable_new_tablespacename();
  PROTOBUF_NODISCARD std::string* release_new_tablespacename();
  void set_allocated_new_tablespacename(std::string* value);

  private:
  const std::string& _internal_new_tablespacename() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 1,
      76, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > roles_;
    ::google::protobuf::internal::ArenaStringPtr orig_tablespacename_;
    ::google::protobuf::internal::ArenaStringPtr new_tablespacename_;
    int objtype_;
    bool nowait_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterTableSpaceOptionsStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTableSpaceOptionsStmt) */ {
 public:
  inline AlterTableSpaceOptionsStmt() : AlterTableSpaceOptionsStmt(nullptr) {}
  ~AlterTableSpaceOptionsStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterTableSpaceOptionsStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt& from)
      : AlterTableSpaceOptionsStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterTableSpaceOptionsStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterTableSpaceOptionsStmt* internal_default_instance() {
    return reinterpret_cast<const AlterTableSpaceOptionsStmt*>(
               &_AlterTableSpaceOptionsStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    153;

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

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

  AlterTableSpaceOptionsStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterTableSpaceOptionsStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterTableSpaceOptionsStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterTableSpaceOptionsStmt& from) {
    AlterTableSpaceOptionsStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterTableSpaceOptionsStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterTableSpaceOptionsStmt";
  }
  protected:
  explicit AlterTableSpaceOptionsStmt(::google::protobuf::Arena* arena);
  AlterTableSpaceOptionsStmt(::google::protobuf::Arena* arena, const AlterTableSpaceOptionsStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string tablespacename = 1 [json_name = "tablespacename"];
  void clear_tablespacename() ;
  const std::string& tablespacename() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_tablespacename(Arg_&& arg, Args_... args);
  std::string* mutable_tablespacename();
  PROTOBUF_NODISCARD std::string* release_tablespacename();
  void set_allocated_tablespacename(std::string* value);

  private:
  const std::string& _internal_tablespacename() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      58, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr tablespacename_;
    bool is_reset_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterTableStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTableStmt) */ {
 public:
  inline AlterTableStmt() : AlterTableStmt(nullptr) {}
  ~AlterTableStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterTableStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterTableStmt(const AlterTableStmt& from)
      : AlterTableStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterTableStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterTableStmt* internal_default_instance() {
    return reinterpret_cast<const AlterTableStmt*>(
               &_AlterTableStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    136;

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

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

  AlterTableStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterTableStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterTableStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterTableStmt& from) {
    AlterTableStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterTableStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterTableStmt";
  }
  protected:
  explicit AlterTableStmt(::google::protobuf::Arena* arena);
  AlterTableStmt(::google::protobuf::Arena* arena, const AlterTableStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kCmdsFieldNumber = 2,
    kRelationFieldNumber = 1,
    kObjtypeFieldNumber = 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_cmds();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_cmds() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_cmds();
  public:
  const ::pg_query::Node& cmds(int index) const;
  ::pg_query::Node* add_cmds();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      cmds() const;
  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  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 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > cmds_;
    ::pg_query::RangeVar* relation_;
    int objtype_;
    bool missing_ok_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterTypeStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTypeStmt) */ {
 public:
  inline AlterTypeStmt() : AlterTypeStmt(nullptr) {}
  ~AlterTypeStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterTypeStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterTypeStmt(const AlterTypeStmt& from)
      : AlterTypeStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterTypeStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterTypeStmt* internal_default_instance() {
    return reinterpret_cast<const AlterTypeStmt*>(
               &_AlterTypeStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    209;

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

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

  AlterTypeStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterTypeStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterTypeStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterTypeStmt& from) {
    AlterTypeStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterTypeStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterTypeStmt";
  }
  protected:
  explicit AlterTypeStmt(::google::protobuf::Arena* arena);
  AlterTypeStmt(::google::protobuf::Arena* arena, const AlterTypeStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_type_name();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_type_name() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_type_name();
  public:
  const ::pg_query::Node& type_name(int index) const;
  ::pg_query::Node* add_type_name();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // @@protoc_insertion_point(class_scope:pg_query.AlterTypeStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > type_name_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlterUserMappingStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterUserMappingStmt) */ {
 public:
  inline AlterUserMappingStmt() : AlterUserMappingStmt(nullptr) {}
  ~AlterUserMappingStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlterUserMappingStmt(::google::protobuf::internal::ConstantInitialized);

  inline AlterUserMappingStmt(const AlterUserMappingStmt& from)
      : AlterUserMappingStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlterUserMappingStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const AlterUserMappingStmt* internal_default_instance() {
    return reinterpret_cast<const AlterUserMappingStmt*>(
               &_AlterUserMappingStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    164;

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

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

  AlterUserMappingStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlterUserMappingStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlterUserMappingStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlterUserMappingStmt& from) {
    AlterUserMappingStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlterUserMappingStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlterUserMappingStmt";
  }
  protected:
  explicit AlterUserMappingStmt(::google::protobuf::Arena* arena);
  AlterUserMappingStmt(::google::protobuf::Arena* arena, const AlterUserMappingStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string servername = 2 [json_name = "servername"];
  void clear_servername() ;
  const std::string& servername() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_servername(Arg_&& arg, Args_... args);
  std::string* mutable_servername();
  PROTOBUF_NODISCARD std::string* release_servername();
  void set_allocated_servername(std::string* value);

  private:
  const std::string& _internal_servername() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_user() ;
  const ::pg_query::RoleSpec& user() const;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_user();
  ::pg_query::RoleSpec* mutable_user();
  void set_allocated_user(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_user(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_user();

  private:
  const ::pg_query::RoleSpec& _internal_user() const;
  ::pg_query::RoleSpec* _internal_mutable_user();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      48, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr servername_;
    ::pg_query::RoleSpec* user_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class AlternativeSubPlan final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.AlternativeSubPlan) */ {
 public:
  inline AlternativeSubPlan() : AlternativeSubPlan(nullptr) {}
  ~AlternativeSubPlan() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AlternativeSubPlan(::google::protobuf::internal::ConstantInitialized);

  inline AlternativeSubPlan(const AlternativeSubPlan& from)
      : AlternativeSubPlan(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AlternativeSubPlan& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlternativeSubPlan* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  AlternativeSubPlan* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AlternativeSubPlan>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlternativeSubPlan& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const AlternativeSubPlan& from) {
    AlternativeSubPlan::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AlternativeSubPlan* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.AlternativeSubPlan";
  }
  protected:
  explicit AlternativeSubPlan(::google::protobuf::Arena* arena);
  AlternativeSubPlan(::google::protobuf::Arena* arena, const AlternativeSubPlan& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_subplans();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_subplans() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_subplans();
  public:
  const ::pg_query::Node& subplans(int index) const;
  ::pg_query::Node* add_subplans();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      subplans() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > subplans_;
    ::pg_query::Node* xpr_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ArrayCoerceExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ArrayCoerceExpr) */ {
 public:
  inline ArrayCoerceExpr() : ArrayCoerceExpr(nullptr) {}
  ~ArrayCoerceExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ArrayCoerceExpr(::google::protobuf::internal::ConstantInitialized);

  inline ArrayCoerceExpr(const ArrayCoerceExpr& from)
      : ArrayCoerceExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ArrayCoerceExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ArrayCoerceExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ArrayCoerceExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ArrayCoerceExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ArrayCoerceExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ArrayCoerceExpr& from) {
    ArrayCoerceExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ArrayCoerceExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ArrayCoerceExpr";
  }
  protected:
  explicit ArrayCoerceExpr(::google::protobuf::Arena* arena);
  ArrayCoerceExpr(::google::protobuf::Arena* arena, const ArrayCoerceExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

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

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // .pg_query.Node elemexpr = 3 [json_name = "elemexpr"];
  bool has_elemexpr() const;
  void clear_elemexpr() ;
  const ::pg_query::Node& elemexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_elemexpr();
  ::pg_query::Node* mutable_elemexpr();
  void set_allocated_elemexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_elemexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_elemexpr();

  private:
  const ::pg_query::Node& _internal_elemexpr() const;
  ::pg_query::Node* _internal_mutable_elemexpr();

  public:
  // uint32 resulttype = 4 [json_name = "resulttype"];
  void clear_resulttype() ;
  ::uint32_t resulttype() const;
  void set_resulttype(::uint32_t value);

  private:
  ::uint32_t _internal_resulttype() const;
  void _internal_set_resulttype(::uint32_t value);

  public:
  // int32 resulttypmod = 5 [json_name = "resulttypmod"];
  void clear_resulttypmod() ;
  ::int32_t resulttypmod() const;
  void set_resulttypmod(::int32_t value);

  private:
  ::int32_t _internal_resulttypmod() const;
  void _internal_set_resulttypmod(::int32_t value);

  public:
  // uint32 resultcollid = 6 [json_name = "resultcollid"];
  void clear_resultcollid() ;
  ::uint32_t resultcollid() const;
  void set_resultcollid(::uint32_t value);

  private:
  ::uint32_t _internal_resultcollid() const;
  void _internal_set_resultcollid(::uint32_t 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* arg_;
    ::pg_query::Node* elemexpr_;
    ::uint32_t resulttype_;
    ::int32_t resulttypmod_;
    ::uint32_t resultcollid_;
    int coerceformat_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ArrayExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ArrayExpr) */ {
 public:
  inline ArrayExpr() : ArrayExpr(nullptr) {}
  ~ArrayExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ArrayExpr(::google::protobuf::internal::ConstantInitialized);

  inline ArrayExpr(const ArrayExpr& from)
      : ArrayExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ArrayExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ArrayExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ArrayExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ArrayExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ArrayExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ArrayExpr& from) {
    ArrayExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ArrayExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ArrayExpr";
  }
  protected:
  explicit ArrayExpr(::google::protobuf::Arena* arena);
  ArrayExpr(::google::protobuf::Arena* arena, const ArrayExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_elements();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_elements() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_elements();
  public:
  const ::pg_query::Node& elements(int index) const;
  ::pg_query::Node* add_elements();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      elements() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 array_typeid = 2 [json_name = "array_typeid"];
  void clear_array_typeid() ;
  ::uint32_t array_typeid() const;
  void set_array_typeid(::uint32_t value);

  private:
  ::uint32_t _internal_array_typeid() const;
  void _internal_set_array_typeid(::uint32_t value);

  public:
  // uint32 array_collid = 3 [json_name = "array_collid"];
  void clear_array_collid() ;
  ::uint32_t array_collid() const;
  void set_array_collid(::uint32_t value);

  private:
  ::uint32_t _internal_array_collid() const;
  void _internal_set_array_collid(::uint32_t value);

  public:
  // uint32 element_typeid = 4 [json_name = "element_typeid"];
  void clear_element_typeid() ;
  ::uint32_t element_typeid() const;
  void set_element_typeid(::uint32_t value);

  private:
  ::uint32_t _internal_element_typeid() const;
  void _internal_set_element_typeid(::uint32_t 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > elements_;
    ::pg_query::Node* xpr_;
    ::uint32_t array_typeid_;
    ::uint32_t array_collid_;
    ::uint32_t element_typeid_;
    bool multidims_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class BoolExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.BoolExpr) */ {
 public:
  inline BoolExpr() : BoolExpr(nullptr) {}
  ~BoolExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR BoolExpr(::google::protobuf::internal::ConstantInitialized);

  inline BoolExpr(const BoolExpr& from)
      : BoolExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BoolExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BoolExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  BoolExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BoolExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const BoolExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const BoolExpr& from) {
    BoolExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(BoolExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.BoolExpr";
  }
  protected:
  explicit BoolExpr(::google::protobuf::Arena* arena);
  BoolExpr(::google::protobuf::Arena* arena, const BoolExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* xpr_;
    int boolop_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class BooleanTest final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.BooleanTest) */ {
 public:
  inline BooleanTest() : BooleanTest(nullptr) {}
  ~BooleanTest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR BooleanTest(::google::protobuf::internal::ConstantInitialized);

  inline BooleanTest(const BooleanTest& from)
      : BooleanTest(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BooleanTest& default_instance() {
    return *internal_default_instance();
  }
  static inline const BooleanTest* internal_default_instance() {
    return reinterpret_cast<const BooleanTest*>(
               &_BooleanTest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    55;

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

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

  BooleanTest* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BooleanTest>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const BooleanTest& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const BooleanTest& from) {
    BooleanTest::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(BooleanTest* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.BooleanTest";
  }
  protected:
  explicit BooleanTest(::google::protobuf::Arena* arena);
  BooleanTest(::google::protobuf::Arena* arena, const BooleanTest& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

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

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // .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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* arg_;
    int booltesttype_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CTECycleClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CTECycleClause) */ {
 public:
  inline CTECycleClause() : CTECycleClause(nullptr) {}
  ~CTECycleClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CTECycleClause(::google::protobuf::internal::ConstantInitialized);

  inline CTECycleClause(const CTECycleClause& from)
      : CTECycleClause(nullptr, from) {}
  CTECycleClause(CTECycleClause&& from) noexcept
    : CTECycleClause() {
    *this = ::std::move(from);
  }

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

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CTECycleClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const CTECycleClause* internal_default_instance() {
    return reinterpret_cast<const CTECycleClause*>(
               &_CTECycleClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    113;

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

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

  CTECycleClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CTECycleClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CTECycleClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CTECycleClause& from) {
    CTECycleClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CTECycleClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CTECycleClause";
  }
  protected:
  explicit CTECycleClause(::google::protobuf::Arena* arena);
  CTECycleClause(::google::protobuf::Arena* arena, const CTECycleClause& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kCycleColListFieldNumber = 1,
    kCycleMarkColumnFieldNumber = 2,
    kCyclePathColumnFieldNumber = 5,
    kCycleMarkValueFieldNumber = 3,
    kCycleMarkDefaultFieldNumber = 4,
    kLocationFieldNumber = 6,
    kCycleMarkTypeFieldNumber = 7,
    kCycleMarkTypmodFieldNumber = 8,
    kCycleMarkCollationFieldNumber = 9,
    kCycleMarkNeopFieldNumber = 10,
  };
  // repeated .pg_query.Node cycle_col_list = 1 [json_name = "cycle_col_list"];
  int cycle_col_list_size() const;
  private:
  int _internal_cycle_col_list_size() const;

  public:
  void clear_cycle_col_list() ;
  ::pg_query::Node* mutable_cycle_col_list(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_cycle_col_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_cycle_col_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_cycle_col_list();
  public:
  const ::pg_query::Node& cycle_col_list(int index) const;
  ::pg_query::Node* add_cycle_col_list();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      cycle_col_list() const;
  // string cycle_mark_column = 2 [json_name = "cycle_mark_column"];
  void clear_cycle_mark_column() ;
  const std::string& cycle_mark_column() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_cycle_mark_column(Arg_&& arg, Args_... args);
  std::string* mutable_cycle_mark_column();
  PROTOBUF_NODISCARD std::string* release_cycle_mark_column();
  void set_allocated_cycle_mark_column(std::string* value);

  private:
  const std::string& _internal_cycle_mark_column() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cycle_mark_column(
      const std::string& value);
  std::string* _internal_mutable_cycle_mark_column();

  public:
  // string cycle_path_column = 5 [json_name = "cycle_path_column"];
  void clear_cycle_path_column() ;
  const std::string& cycle_path_column() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_cycle_path_column(Arg_&& arg, Args_... args);
  std::string* mutable_cycle_path_column();
  PROTOBUF_NODISCARD std::string* release_cycle_path_column();
  void set_allocated_cycle_path_column(std::string* value);

  private:
  const std::string& _internal_cycle_path_column() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cycle_path_column(
      const std::string& value);
  std::string* _internal_mutable_cycle_path_column();

  public:
  // .pg_query.Node cycle_mark_value = 3 [json_name = "cycle_mark_value"];
  bool has_cycle_mark_value() const;
  void clear_cycle_mark_value() ;
  const ::pg_query::Node& cycle_mark_value() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_cycle_mark_value();
  ::pg_query::Node* mutable_cycle_mark_value();
  void set_allocated_cycle_mark_value(::pg_query::Node* value);
  void unsafe_arena_set_allocated_cycle_mark_value(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_cycle_mark_value();

  private:
  const ::pg_query::Node& _internal_cycle_mark_value() const;
  ::pg_query::Node* _internal_mutable_cycle_mark_value();

  public:
  // .pg_query.Node cycle_mark_default = 4 [json_name = "cycle_mark_default"];
  bool has_cycle_mark_default() const;
  void clear_cycle_mark_default() ;
  const ::pg_query::Node& cycle_mark_default() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_cycle_mark_default();
  ::pg_query::Node* mutable_cycle_mark_default();
  void set_allocated_cycle_mark_default(::pg_query::Node* value);
  void unsafe_arena_set_allocated_cycle_mark_default(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_cycle_mark_default();

  private:
  const ::pg_query::Node& _internal_cycle_mark_default() const;
  ::pg_query::Node* _internal_mutable_cycle_mark_default();

  public:
  // int32 location = 6 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // uint32 cycle_mark_type = 7 [json_name = "cycle_mark_type"];
  void clear_cycle_mark_type() ;
  ::uint32_t cycle_mark_type() const;
  void set_cycle_mark_type(::uint32_t value);

  private:
  ::uint32_t _internal_cycle_mark_type() const;
  void _internal_set_cycle_mark_type(::uint32_t value);

  public:
  // int32 cycle_mark_typmod = 8 [json_name = "cycle_mark_typmod"];
  void clear_cycle_mark_typmod() ;
  ::int32_t cycle_mark_typmod() const;
  void set_cycle_mark_typmod(::int32_t value);

  private:
  ::int32_t _internal_cycle_mark_typmod() const;
  void _internal_set_cycle_mark_typmod(::int32_t value);

  public:
  // uint32 cycle_mark_collation = 9 [json_name = "cycle_mark_collation"];
  void clear_cycle_mark_collation() ;
  ::uint32_t cycle_mark_collation() const;
  void set_cycle_mark_collation(::uint32_t value);

  private:
  ::uint32_t _internal_cycle_mark_collation() const;
  void _internal_set_cycle_mark_collation(::uint32_t value);

  public:
  // uint32 cycle_mark_neop = 10 [json_name = "cycle_mark_neop"];
  void clear_cycle_mark_neop() ;
  ::uint32_t cycle_mark_neop() const;
  void set_cycle_mark_neop(::uint32_t value);

  private:
  ::uint32_t _internal_cycle_mark_neop() const;
  void _internal_set_cycle_mark_neop(::uint32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 10, 3,
      74, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > cycle_col_list_;
    ::google::protobuf::internal::ArenaStringPtr cycle_mark_column_;
    ::google::protobuf::internal::ArenaStringPtr cycle_path_column_;
    ::pg_query::Node* cycle_mark_value_;
    ::pg_query::Node* cycle_mark_default_;
    ::int32_t location_;
    ::uint32_t cycle_mark_type_;
    ::int32_t cycle_mark_typmod_;
    ::uint32_t cycle_mark_collation_;
    ::uint32_t cycle_mark_neop_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CTESearchClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CTESearchClause) */ {
 public:
  inline CTESearchClause() : CTESearchClause(nullptr) {}
  ~CTESearchClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CTESearchClause(::google::protobuf::internal::ConstantInitialized);

  inline CTESearchClause(const CTESearchClause& from)
      : CTESearchClause(nullptr, from) {}
  CTESearchClause(CTESearchClause&& from) noexcept
    : CTESearchClause() {
    *this = ::std::move(from);
  }

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

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CTESearchClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const CTESearchClause* internal_default_instance() {
    return reinterpret_cast<const CTESearchClause*>(
               &_CTESearchClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    112;

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

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

  CTESearchClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CTESearchClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CTESearchClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CTESearchClause& from) {
    CTESearchClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CTESearchClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CTESearchClause";
  }
  protected:
  explicit CTESearchClause(::google::protobuf::Arena* arena);
  CTESearchClause(::google::protobuf::Arena* arena, const CTESearchClause& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSearchColListFieldNumber = 1,
    kSearchSeqColumnFieldNumber = 3,
    kSearchBreadthFirstFieldNumber = 2,
    kLocationFieldNumber = 4,
  };
  // repeated .pg_query.Node search_col_list = 1 [json_name = "search_col_list"];
  int search_col_list_size() const;
  private:
  int _internal_search_col_list_size() const;

  public:
  void clear_search_col_list() ;
  ::pg_query::Node* mutable_search_col_list(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_search_col_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_search_col_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_search_col_list();
  public:
  const ::pg_query::Node& search_col_list(int index) const;
  ::pg_query::Node* add_search_col_list();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      search_col_list() const;
  // string search_seq_column = 3 [json_name = "search_seq_column"];
  void clear_search_seq_column() ;
  const std::string& search_seq_column() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_search_seq_column(Arg_&& arg, Args_... args);
  std::string* mutable_search_seq_column();
  PROTOBUF_NODISCARD std::string* release_search_seq_column();
  void set_allocated_search_seq_column(std::string* value);

  private:
  const std::string& _internal_search_seq_column() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_search_seq_column(
      const std::string& value);
  std::string* _internal_mutable_search_seq_column();

  public:
  // bool search_breadth_first = 2 [json_name = "search_breadth_first"];
  void clear_search_breadth_first() ;
  bool search_breadth_first() const;
  void set_search_breadth_first(bool value);

  private:
  bool _internal_search_breadth_first() const;
  void _internal_set_search_breadth_first(bool value);

  public:
  // int32 location = 4 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 1,
      50, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > search_col_list_;
    ::google::protobuf::internal::ArenaStringPtr search_seq_column_;
    bool search_breadth_first_;
    ::int32_t location_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CallStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CallStmt) */ {
 public:
  inline CallStmt() : CallStmt(nullptr) {}
  ~CallStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CallStmt(::google::protobuf::internal::ConstantInitialized);

  inline CallStmt(const CallStmt& from)
      : CallStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CallStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CallStmt* internal_default_instance() {
    return reinterpret_cast<const CallStmt*>(
               &_CallStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    202;

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

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

  CallStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CallStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CallStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CallStmt& from) {
    CallStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CallStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CallStmt";
  }
  protected:
  explicit CallStmt(::google::protobuf::Arena* arena);
  CallStmt(::google::protobuf::Arena* arena, const CallStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kOutargsFieldNumber = 3,
    kFunccallFieldNumber = 1,
    kFuncexprFieldNumber = 2,
  };
  // repeated .pg_query.Node outargs = 3 [json_name = "outargs"];
  int outargs_size() const;
  private:
  int _internal_outargs_size() const;

  public:
  void clear_outargs() ;
  ::pg_query::Node* mutable_outargs(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_outargs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_outargs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_outargs();
  public:
  const ::pg_query::Node& outargs(int index) const;
  ::pg_query::Node* add_outargs();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      outargs() const;
  // .pg_query.FuncCall funccall = 1 [json_name = "funccall"];
  bool has_funccall() const;
  void clear_funccall() ;
  const ::pg_query::FuncCall& funccall() const;
  PROTOBUF_NODISCARD ::pg_query::FuncCall* release_funccall();
  ::pg_query::FuncCall* mutable_funccall();
  void set_allocated_funccall(::pg_query::FuncCall* value);
  void unsafe_arena_set_allocated_funccall(::pg_query::FuncCall* value);
  ::pg_query::FuncCall* unsafe_arena_release_funccall();

  private:
  const ::pg_query::FuncCall& _internal_funccall() const;
  ::pg_query::FuncCall* _internal_mutable_funccall();

  public:
  // .pg_query.FuncExpr funcexpr = 2 [json_name = "funcexpr"];
  bool has_funcexpr() const;
  void clear_funcexpr() ;
  const ::pg_query::FuncExpr& funcexpr() const;
  PROTOBUF_NODISCARD ::pg_query::FuncExpr* release_funcexpr();
  ::pg_query::FuncExpr* mutable_funcexpr();
  void set_allocated_funcexpr(::pg_query::FuncExpr* value);
  void unsafe_arena_set_allocated_funcexpr(::pg_query::FuncExpr* value);
  ::pg_query::FuncExpr* unsafe_arena_release_funcexpr();

  private:
  const ::pg_query::FuncExpr& _internal_funcexpr() const;
  ::pg_query::FuncExpr* _internal_mutable_funcexpr();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > outargs_;
    ::pg_query::FuncCall* funccall_;
    ::pg_query::FuncExpr* funcexpr_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CaseExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CaseExpr) */ {
 public:
  inline CaseExpr() : CaseExpr(nullptr) {}
  ~CaseExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CaseExpr(::google::protobuf::internal::ConstantInitialized);

  inline CaseExpr(const CaseExpr& from)
      : CaseExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CaseExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CaseExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  CaseExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CaseExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CaseExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CaseExpr& from) {
    CaseExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CaseExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CaseExpr";
  }
  protected:
  explicit CaseExpr(::google::protobuf::Arena* arena);
  CaseExpr(::google::protobuf::Arena* arena, const CaseExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node arg = 4 [json_name = "arg"];
  bool has_arg() const;
  void clear_arg() ;
  const ::pg_query::Node& arg() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* value);
  void unsafe_arena_set_allocated_arg(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_arg();

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // .pg_query.Node defresult = 6 [json_name = "defresult"];
  bool has_defresult() const;
  void clear_defresult() ;
  const ::pg_query::Node& defresult() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_defresult();
  ::pg_query::Node* mutable_defresult();
  void set_allocated_defresult(::pg_query::Node* value);
  void unsafe_arena_set_allocated_defresult(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_defresult();

  private:
  const ::pg_query::Node& _internal_defresult() const;
  ::pg_query::Node* _internal_mutable_defresult();

  public:
  // uint32 casetype = 2 [json_name = "casetype"];
  void clear_casetype() ;
  ::uint32_t casetype() const;
  void set_casetype(::uint32_t value);

  private:
  ::uint32_t _internal_casetype() const;
  void _internal_set_casetype(::uint32_t value);

  public:
  // uint32 casecollid = 3 [json_name = "casecollid"];
  void clear_casecollid() ;
  ::uint32_t casecollid() const;
  void set_casecollid(::uint32_t value);

  private:
  ::uint32_t _internal_casecollid() const;
  void _internal_set_casecollid(::uint32_t value);

  public:
  // int32 location = 7 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 4,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* arg_;
    ::pg_query::Node* defresult_;
    ::uint32_t casetype_;
    ::uint32_t casecollid_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CaseTestExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CaseTestExpr) */ {
 public:
  inline CaseTestExpr() : CaseTestExpr(nullptr) {}
  ~CaseTestExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CaseTestExpr(::google::protobuf::internal::ConstantInitialized);

  inline CaseTestExpr(const CaseTestExpr& from)
      : CaseTestExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CaseTestExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CaseTestExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  CaseTestExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CaseTestExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CaseTestExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CaseTestExpr& from) {
    CaseTestExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CaseTestExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CaseTestExpr";
  }
  protected:
  explicit CaseTestExpr(::google::protobuf::Arena* arena);
  CaseTestExpr(::google::protobuf::Arena* arena, const CaseTestExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 type_id = 2 [json_name = "typeId"];
  void clear_type_id() ;
  ::uint32_t type_id() const;
  void set_type_id(::uint32_t value);

  private:
  ::uint32_t _internal_type_id() const;
  void _internal_set_type_id(::uint32_t value);

  public:
  // int32 type_mod = 3 [json_name = "typeMod"];
  void clear_type_mod() ;
  ::int32_t type_mod() const;
  void set_type_mod(::int32_t value);

  private:
  ::int32_t _internal_type_mod() const;
  void _internal_set_type_mod(::int32_t value);

  public:
  // uint32 collation = 4 [json_name = "collation"];
  void clear_collation() ;
  ::uint32_t collation() const;
  void set_collation(::uint32_t value);

  private:
  ::uint32_t _internal_collation() const;
  void _internal_set_collation(::uint32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::uint32_t type_id_;
    ::int32_t type_mod_;
    ::uint32_t collation_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CaseWhen final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CaseWhen) */ {
 public:
  inline CaseWhen() : CaseWhen(nullptr) {}
  ~CaseWhen() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CaseWhen(::google::protobuf::internal::ConstantInitialized);

  inline CaseWhen(const CaseWhen& from)
      : CaseWhen(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CaseWhen& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CaseWhen* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  CaseWhen* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CaseWhen>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CaseWhen& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CaseWhen& from) {
    CaseWhen::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CaseWhen* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CaseWhen";
  }
  protected:
  explicit CaseWhen(::google::protobuf::Arena* arena);
  CaseWhen(::google::protobuf::Arena* arena, const CaseWhen& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node expr = 2 [json_name = "expr"];
  bool has_expr() const;
  void clear_expr() ;
  const ::pg_query::Node& expr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_expr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_expr();

  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();

  public:
  // .pg_query.Node result = 3 [json_name = "result"];
  bool has_result() const;
  void clear_result() ;
  const ::pg_query::Node& result() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_result();
  ::pg_query::Node* mutable_result();
  void set_allocated_result(::pg_query::Node* value);
  void unsafe_arena_set_allocated_result(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_result();

  private:
  const ::pg_query::Node& _internal_result() const;
  ::pg_query::Node* _internal_mutable_result();

  public:
  // int32 location = 4 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* expr_;
    ::pg_query::Node* result_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ClusterStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ClusterStmt) */ {
 public:
  inline ClusterStmt() : ClusterStmt(nullptr) {}
  ~ClusterStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ClusterStmt(::google::protobuf::internal::ConstantInitialized);

  inline ClusterStmt(const ClusterStmt& from)
      : ClusterStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ClusterStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClusterStmt* internal_default_instance() {
    return reinterpret_cast<const ClusterStmt*>(
               &_ClusterStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    227;

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

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

  ClusterStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ClusterStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ClusterStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ClusterStmt& from) {
    ClusterStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ClusterStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ClusterStmt";
  }
  protected:
  explicit ClusterStmt(::google::protobuf::Arena* arena);
  ClusterStmt(::google::protobuf::Arena* arena, const ClusterStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kParamsFieldNumber = 3,
    kIndexnameFieldNumber = 2,
    kRelationFieldNumber = 1,
  };
  // repeated .pg_query.Node params = 3 [json_name = "params"];
  int params_size() const;
  private:
  int _internal_params_size() const;

  public:
  void clear_params() ;
  ::pg_query::Node* mutable_params(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_params();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_params() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_params();
  public:
  const ::pg_query::Node& params(int index) const;
  ::pg_query::Node* add_params();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      params() const;
  // string indexname = 2 [json_name = "indexname"];
  void clear_indexname() ;
  const std::string& indexname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_indexname(Arg_&& arg, Args_... args);
  std::string* mutable_indexname();
  PROTOBUF_NODISCARD std::string* release_indexname();
  void set_allocated_indexname(std::string* value);

  private:
  const std::string& _internal_indexname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      38, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > params_;
    ::google::protobuf::internal::ArenaStringPtr indexname_;
    ::pg_query::RangeVar* relation_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CoalesceExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CoalesceExpr) */ {
 public:
  inline CoalesceExpr() : CoalesceExpr(nullptr) {}
  ~CoalesceExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CoalesceExpr(::google::protobuf::internal::ConstantInitialized);

  inline CoalesceExpr(const CoalesceExpr& from)
      : CoalesceExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CoalesceExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CoalesceExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  CoalesceExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CoalesceExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CoalesceExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CoalesceExpr& from) {
    CoalesceExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CoalesceExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CoalesceExpr";
  }
  protected:
  explicit CoalesceExpr(::google::protobuf::Arena* arena);
  CoalesceExpr(::google::protobuf::Arena* arena, const CoalesceExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 coalescetype = 2 [json_name = "coalescetype"];
  void clear_coalescetype() ;
  ::uint32_t coalescetype() const;
  void set_coalescetype(::uint32_t value);

  private:
  ::uint32_t _internal_coalescetype() const;
  void _internal_set_coalescetype(::uint32_t value);

  public:
  // uint32 coalescecollid = 3 [json_name = "coalescecollid"];
  void clear_coalescecollid() ;
  ::uint32_t coalescecollid() const;
  void set_coalescecollid(::uint32_t value);

  private:
  ::uint32_t _internal_coalescecollid() const;
  void _internal_set_coalescecollid(::uint32_t value);

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* xpr_;
    ::uint32_t coalescetype_;
    ::uint32_t coalescecollid_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CoerceToDomain final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CoerceToDomain) */ {
 public:
  inline CoerceToDomain() : CoerceToDomain(nullptr) {}
  ~CoerceToDomain() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CoerceToDomain(::google::protobuf::internal::ConstantInitialized);

  inline CoerceToDomain(const CoerceToDomain& from)
      : CoerceToDomain(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CoerceToDomain& default_instance() {
    return *internal_default_instance();
  }
  static inline const CoerceToDomain* internal_default_instance() {
    return reinterpret_cast<const CoerceToDomain*>(
               &_CoerceToDomain_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    56;

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

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

  CoerceToDomain* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CoerceToDomain>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CoerceToDomain& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CoerceToDomain& from) {
    CoerceToDomain::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CoerceToDomain* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CoerceToDomain";
  }
  protected:
  explicit CoerceToDomain(::google::protobuf::Arena* arena);
  CoerceToDomain(::google::protobuf::Arena* arena, const CoerceToDomain& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

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

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // uint32 resulttype = 3 [json_name = "resulttype"];
  void clear_resulttype() ;
  ::uint32_t resulttype() const;
  void set_resulttype(::uint32_t value);

  private:
  ::uint32_t _internal_resulttype() const;
  void _internal_set_resulttype(::uint32_t value);

  public:
  // int32 resulttypmod = 4 [json_name = "resulttypmod"];
  void clear_resulttypmod() ;
  ::int32_t resulttypmod() const;
  void set_resulttypmod(::int32_t value);

  private:
  ::int32_t _internal_resulttypmod() const;
  void _internal_set_resulttypmod(::int32_t value);

  public:
  // uint32 resultcollid = 5 [json_name = "resultcollid"];
  void clear_resultcollid() ;
  ::uint32_t resultcollid() const;
  void set_resultcollid(::uint32_t value);

  private:
  ::uint32_t _internal_resultcollid() const;
  void _internal_set_resultcollid(::uint32_t 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* arg_;
    ::uint32_t resulttype_;
    ::int32_t resulttypmod_;
    ::uint32_t resultcollid_;
    int coercionformat_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CoerceToDomainValue final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CoerceToDomainValue) */ {
 public:
  inline CoerceToDomainValue() : CoerceToDomainValue(nullptr) {}
  ~CoerceToDomainValue() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CoerceToDomainValue(::google::protobuf::internal::ConstantInitialized);

  inline CoerceToDomainValue(const CoerceToDomainValue& from)
      : CoerceToDomainValue(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CoerceToDomainValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const CoerceToDomainValue* internal_default_instance() {
    return reinterpret_cast<const CoerceToDomainValue*>(
               &_CoerceToDomainValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    57;

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

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

  CoerceToDomainValue* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CoerceToDomainValue>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CoerceToDomainValue& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CoerceToDomainValue& from) {
    CoerceToDomainValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CoerceToDomainValue* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CoerceToDomainValue";
  }
  protected:
  explicit CoerceToDomainValue(::google::protobuf::Arena* arena);
  CoerceToDomainValue(::google::protobuf::Arena* arena, const CoerceToDomainValue& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 type_id = 2 [json_name = "typeId"];
  void clear_type_id() ;
  ::uint32_t type_id() const;
  void set_type_id(::uint32_t value);

  private:
  ::uint32_t _internal_type_id() const;
  void _internal_set_type_id(::uint32_t value);

  public:
  // int32 type_mod = 3 [json_name = "typeMod"];
  void clear_type_mod() ;
  ::int32_t type_mod() const;
  void set_type_mod(::int32_t value);

  private:
  ::int32_t _internal_type_mod() const;
  void _internal_set_type_mod(::int32_t value);

  public:
  // uint32 collation = 4 [json_name = "collation"];
  void clear_collation() ;
  ::uint32_t collation() const;
  void set_collation(::uint32_t value);

  private:
  ::uint32_t _internal_collation() const;
  void _internal_set_collation(::uint32_t value);

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::uint32_t type_id_;
    ::int32_t type_mod_;
    ::uint32_t collation_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CoerceViaIO final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CoerceViaIO) */ {
 public:
  inline CoerceViaIO() : CoerceViaIO(nullptr) {}
  ~CoerceViaIO() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CoerceViaIO(::google::protobuf::internal::ConstantInitialized);

  inline CoerceViaIO(const CoerceViaIO& from)
      : CoerceViaIO(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CoerceViaIO& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CoerceViaIO* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  CoerceViaIO* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CoerceViaIO>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CoerceViaIO& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CoerceViaIO& from) {
    CoerceViaIO::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CoerceViaIO* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CoerceViaIO";
  }
  protected:
  explicit CoerceViaIO(::google::protobuf::Arena* arena);
  CoerceViaIO(::google::protobuf::Arena* arena, const CoerceViaIO& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

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

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // uint32 resulttype = 3 [json_name = "resulttype"];
  void clear_resulttype() ;
  ::uint32_t resulttype() const;
  void set_resulttype(::uint32_t value);

  private:
  ::uint32_t _internal_resulttype() const;
  void _internal_set_resulttype(::uint32_t value);

  public:
  // uint32 resultcollid = 4 [json_name = "resultcollid"];
  void clear_resultcollid() ;
  ::uint32_t resultcollid() const;
  void set_resultcollid(::uint32_t value);

  private:
  ::uint32_t _internal_resultcollid() const;
  void _internal_set_resultcollid(::uint32_t 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* arg_;
    ::uint32_t resulttype_;
    ::uint32_t resultcollid_;
    int coerceformat_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CollateClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CollateClause) */ {
 public:
  inline CollateClause() : CollateClause(nullptr) {}
  ~CollateClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CollateClause(::google::protobuf::internal::ConstantInitialized);

  inline CollateClause(const CollateClause& from)
      : CollateClause(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CollateClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const CollateClause* internal_default_instance() {
    return reinterpret_cast<const CollateClause*>(
               &_CollateClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    73;

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

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

  CollateClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CollateClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CollateClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CollateClause& from) {
    CollateClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CollateClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CollateClause";
  }
  protected:
  explicit CollateClause(::google::protobuf::Arena* arena);
  CollateClause(::google::protobuf::Arena* arena, const CollateClause& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_collname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_collname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_collname();
  public:
  const ::pg_query::Node& collname(int index) const;
  ::pg_query::Node* add_collname();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      collname() const;
  // .pg_query.Node arg = 1 [json_name = "arg"];
  bool has_arg() const;
  void clear_arg() ;
  const ::pg_query::Node& arg() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* value);
  void unsafe_arena_set_allocated_arg(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_arg();

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // int32 location = 3 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > collname_;
    ::pg_query::Node* arg_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CollateExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CollateExpr) */ {
 public:
  inline CollateExpr() : CollateExpr(nullptr) {}
  ~CollateExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CollateExpr(::google::protobuf::internal::ConstantInitialized);

  inline CollateExpr(const CollateExpr& from)
      : CollateExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CollateExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CollateExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  CollateExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CollateExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CollateExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CollateExpr& from) {
    CollateExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CollateExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CollateExpr";
  }
  protected:
  explicit CollateExpr(::google::protobuf::Arena* arena);
  CollateExpr(::google::protobuf::Arena* arena, const CollateExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

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

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // uint32 coll_oid = 3 [json_name = "collOid"];
  void clear_coll_oid() ;
  ::uint32_t coll_oid() const;
  void set_coll_oid(::uint32_t value);

  private:
  ::uint32_t _internal_coll_oid() const;
  void _internal_set_coll_oid(::uint32_t value);

  public:
  // int32 location = 4 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* arg_;
    ::uint32_t coll_oid_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ColumnDef final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ColumnDef) */ {
 public:
  inline ColumnDef() : ColumnDef(nullptr) {}
  ~ColumnDef() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ColumnDef(::google::protobuf::internal::ConstantInitialized);

  inline ColumnDef(const ColumnDef& from)
      : ColumnDef(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ColumnDef& default_instance() {
    return *internal_default_instance();
  }
  static inline const ColumnDef* internal_default_instance() {
    return reinterpret_cast<const ColumnDef*>(
               &_ColumnDef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    89;

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

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

  ColumnDef* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ColumnDef>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ColumnDef& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ColumnDef& from) {
    ColumnDef::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ColumnDef* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ColumnDef";
  }
  protected:
  explicit ColumnDef(::google::protobuf::Arena* arena);
  ColumnDef(::google::protobuf::Arena* arena, const ColumnDef& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kConstraintsFieldNumber = 17,
    kFdwoptionsFieldNumber = 18,
    kColnameFieldNumber = 1,
    kCompressionFieldNumber = 3,
    kStorageFieldNumber = 8,
    kStorageNameFieldNumber = 9,
    kIdentityFieldNumber = 12,
    kGeneratedFieldNumber = 14,
    kTypeNameFieldNumber = 2,
    kRawDefaultFieldNumber = 10,
    kCookedDefaultFieldNumber = 11,
    kIdentitySequenceFieldNumber = 13,
    kCollClauseFieldNumber = 15,
    kInhcountFieldNumber = 4,
    kIsLocalFieldNumber = 5,
    kIsNotNullFieldNumber = 6,
    kIsFromTypeFieldNumber = 7,
    kCollOidFieldNumber = 16,
    kLocationFieldNumber = 19,
  };
  // repeated .pg_query.Node constraints = 17 [json_name = "constraints"];
  int constraints_size() const;
  private:
  int _internal_constraints_size() const;

  public:
  void clear_constraints() ;
  ::pg_query::Node* mutable_constraints(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_constraints();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_constraints() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_constraints();
  public:
  const ::pg_query::Node& constraints(int index) const;
  ::pg_query::Node* add_constraints();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      constraints() const;
  // repeated .pg_query.Node fdwoptions = 18 [json_name = "fdwoptions"];
  int fdwoptions_size() const;
  private:
  int _internal_fdwoptions_size() const;

  public:
  void clear_fdwoptions() ;
  ::pg_query::Node* mutable_fdwoptions(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_fdwoptions();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_fdwoptions() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_fdwoptions();
  public:
  const ::pg_query::Node& fdwoptions(int index) const;
  ::pg_query::Node* add_fdwoptions();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      fdwoptions() const;
  // string colname = 1 [json_name = "colname"];
  void clear_colname() ;
  const std::string& colname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_colname(Arg_&& arg, Args_... args);
  std::string* mutable_colname();
  PROTOBUF_NODISCARD std::string* release_colname();
  void set_allocated_colname(std::string* value);

  private:
  const std::string& _internal_colname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_colname(
      const std::string& value);
  std::string* _internal_mutable_colname();

  public:
  // string compression = 3 [json_name = "compression"];
  void clear_compression() ;
  const std::string& compression() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_compression(Arg_&& arg, Args_... args);
  std::string* mutable_compression();
  PROTOBUF_NODISCARD std::string* release_compression();
  void set_allocated_compression(std::string* value);

  private:
  const std::string& _internal_compression() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_compression(
      const std::string& value);
  std::string* _internal_mutable_compression();

  public:
  // string storage = 8 [json_name = "storage"];
  void clear_storage() ;
  const std::string& storage() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_storage(Arg_&& arg, Args_... args);
  std::string* mutable_storage();
  PROTOBUF_NODISCARD std::string* release_storage();
  void set_allocated_storage(std::string* value);

  private:
  const std::string& _internal_storage() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_storage(
      const std::string& value);
  std::string* _internal_mutable_storage();

  public:
  // string storage_name = 9 [json_name = "storage_name"];
  void clear_storage_name() ;
  const std::string& storage_name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_storage_name(Arg_&& arg, Args_... args);
  std::string* mutable_storage_name();
  PROTOBUF_NODISCARD std::string* release_storage_name();
  void set_allocated_storage_name(std::string* value);

  private:
  const std::string& _internal_storage_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_storage_name(
      const std::string& value);
  std::string* _internal_mutable_storage_name();

  public:
  // string identity = 12 [json_name = "identity"];
  void clear_identity() ;
  const std::string& identity() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_identity(Arg_&& arg, Args_... args);
  std::string* mutable_identity();
  PROTOBUF_NODISCARD std::string* release_identity();
  void set_allocated_identity(std::string* value);

  private:
  const std::string& _internal_identity() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_identity(
      const std::string& value);
  std::string* _internal_mutable_identity();

  public:
  // string generated = 14 [json_name = "generated"];
  void clear_generated() ;
  const std::string& generated() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_generated(Arg_&& arg, Args_... args);
  std::string* mutable_generated();
  PROTOBUF_NODISCARD std::string* release_generated();
  void set_allocated_generated(std::string* value);

  private:
  const std::string& _internal_generated() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_type_name() ;
  const ::pg_query::TypeName& type_name() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_type_name(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();

  public:
  // .pg_query.Node raw_default = 10 [json_name = "raw_default"];
  bool has_raw_default() const;
  void clear_raw_default() ;
  const ::pg_query::Node& raw_default() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_raw_default();
  ::pg_query::Node* mutable_raw_default();
  void set_allocated_raw_default(::pg_query::Node* value);
  void unsafe_arena_set_allocated_raw_default(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_raw_default();

  private:
  const ::pg_query::Node& _internal_raw_default() const;
  ::pg_query::Node* _internal_mutable_raw_default();

  public:
  // .pg_query.Node cooked_default = 11 [json_name = "cooked_default"];
  bool has_cooked_default() const;
  void clear_cooked_default() ;
  const ::pg_query::Node& cooked_default() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_cooked_default();
  ::pg_query::Node* mutable_cooked_default();
  void set_allocated_cooked_default(::pg_query::Node* value);
  void unsafe_arena_set_allocated_cooked_default(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_cooked_default();

  private:
  const ::pg_query::Node& _internal_cooked_default() const;
  ::pg_query::Node* _internal_mutable_cooked_default();

  public:
  // .pg_query.RangeVar identity_sequence = 13 [json_name = "identitySequence"];
  bool has_identity_sequence() const;
  void clear_identity_sequence() ;
  const ::pg_query::RangeVar& identity_sequence() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_identity_sequence();
  ::pg_query::RangeVar* mutable_identity_sequence();
  void set_allocated_identity_sequence(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_identity_sequence(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_identity_sequence();

  private:
  const ::pg_query::RangeVar& _internal_identity_sequence() const;
  ::pg_query::RangeVar* _internal_mutable_identity_sequence();

  public:
  // .pg_query.CollateClause coll_clause = 15 [json_name = "collClause"];
  bool has_coll_clause() const;
  void clear_coll_clause() ;
  const ::pg_query::CollateClause& coll_clause() const;
  PROTOBUF_NODISCARD ::pg_query::CollateClause* release_coll_clause();
  ::pg_query::CollateClause* mutable_coll_clause();
  void set_allocated_coll_clause(::pg_query::CollateClause* value);
  void unsafe_arena_set_allocated_coll_clause(::pg_query::CollateClause* value);
  ::pg_query::CollateClause* unsafe_arena_release_coll_clause();

  private:
  const ::pg_query::CollateClause& _internal_coll_clause() const;
  ::pg_query::CollateClause* _internal_mutable_coll_clause();

  public:
  // int32 inhcount = 4 [json_name = "inhcount"];
  void clear_inhcount() ;
  ::int32_t inhcount() const;
  void set_inhcount(::int32_t value);

  private:
  ::int32_t _internal_inhcount() const;
  void _internal_set_inhcount(::int32_t value);

  public:
  // bool is_local = 5 [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 = 6 [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 = 7 [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 = 16 [json_name = "collOid"];
  void clear_coll_oid() ;
  ::uint32_t coll_oid() const;
  void set_coll_oid(::uint32_t value);

  private:
  ::uint32_t _internal_coll_oid() const;
  void _internal_set_coll_oid(::uint32_t value);

  public:
  // int32 location = 19 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      5, 19, 7,
      97, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > constraints_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > fdwoptions_;
    ::google::protobuf::internal::ArenaStringPtr colname_;
    ::google::protobuf::internal::ArenaStringPtr compression_;
    ::google::protobuf::internal::ArenaStringPtr storage_;
    ::google::protobuf::internal::ArenaStringPtr storage_name_;
    ::google::protobuf::internal::ArenaStringPtr identity_;
    ::google::protobuf::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_;
    ::int32_t inhcount_;
    bool is_local_;
    bool is_not_null_;
    bool is_from_type_;
    ::uint32_t coll_oid_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ColumnRef final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ColumnRef) */ {
 public:
  inline ColumnRef() : ColumnRef(nullptr) {}
  ~ColumnRef() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ColumnRef(::google::protobuf::internal::ConstantInitialized);

  inline ColumnRef(const ColumnRef& from)
      : ColumnRef(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ColumnRef& default_instance() {
    return *internal_default_instance();
  }
  static inline const ColumnRef* internal_default_instance() {
    return reinterpret_cast<const ColumnRef*>(
               &_ColumnRef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    69;

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

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

  ColumnRef* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ColumnRef>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ColumnRef& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ColumnRef& from) {
    ColumnRef::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ColumnRef* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ColumnRef";
  }
  protected:
  explicit ColumnRef(::google::protobuf::Arena* arena);
  ColumnRef(::google::protobuf::Arena* arena, const ColumnRef& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_fields();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_fields() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_fields();
  public:
  const ::pg_query::Node& fields(int index) const;
  ::pg_query::Node* add_fields();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      fields() const;
  // int32 location = 2 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > fields_;
    ::int32_t location_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CommentStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CommentStmt) */ {
 public:
  inline CommentStmt() : CommentStmt(nullptr) {}
  ~CommentStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CommentStmt(::google::protobuf::internal::ConstantInitialized);

  inline CommentStmt(const CommentStmt& from)
      : CommentStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CommentStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CommentStmt* internal_default_instance() {
    return reinterpret_cast<const CommentStmt*>(
               &_CommentStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    188;

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

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

  CommentStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CommentStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CommentStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CommentStmt& from) {
    CommentStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CommentStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CommentStmt";
  }
  protected:
  explicit CommentStmt(::google::protobuf::Arena* arena);
  CommentStmt(::google::protobuf::Arena* arena, const CommentStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_comment(Arg_&& arg, Args_... args);
  std::string* mutable_comment();
  PROTOBUF_NODISCARD std::string* release_comment();
  void set_allocated_comment(std::string* value);

  private:
  const std::string& _internal_comment() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_object() ;
  const ::pg_query::Node& object() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* value);
  void unsafe_arena_set_allocated_object(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_object();

  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      36, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr comment_;
    ::pg_query::Node* object_;
    int objtype_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CommonTableExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CommonTableExpr) */ {
 public:
  inline CommonTableExpr() : CommonTableExpr(nullptr) {}
  ~CommonTableExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CommonTableExpr(::google::protobuf::internal::ConstantInitialized);

  inline CommonTableExpr(const CommonTableExpr& from)
      : CommonTableExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CommonTableExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const CommonTableExpr* internal_default_instance() {
    return reinterpret_cast<const CommonTableExpr*>(
               &_CommonTableExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    114;

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

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

  CommonTableExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CommonTableExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CommonTableExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CommonTableExpr& from) {
    CommonTableExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CommonTableExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CommonTableExpr";
  }
  protected:
  explicit CommonTableExpr(::google::protobuf::Arena* arena);
  CommonTableExpr(::google::protobuf::Arena* arena, const CommonTableExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kAliascolnamesFieldNumber = 2,
    kCtecolnamesFieldNumber = 10,
    kCtecoltypesFieldNumber = 11,
    kCtecoltypmodsFieldNumber = 12,
    kCtecolcollationsFieldNumber = 13,
    kCtenameFieldNumber = 1,
    kCtequeryFieldNumber = 4,
    kSearchClauseFieldNumber = 5,
    kCycleClauseFieldNumber = 6,
    kCtematerializedFieldNumber = 3,
    kLocationFieldNumber = 7,
    kCterecursiveFieldNumber = 8,
    kCterefcountFieldNumber = 9,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_aliascolnames();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_aliascolnames() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_aliascolnames();
  public:
  const ::pg_query::Node& aliascolnames(int index) const;
  ::pg_query::Node* add_aliascolnames();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      aliascolnames() const;
  // repeated .pg_query.Node ctecolnames = 10 [json_name = "ctecolnames"];
  int ctecolnames_size() const;
  private:
  int _internal_ctecolnames_size() const;

  public:
  void clear_ctecolnames() ;
  ::pg_query::Node* mutable_ctecolnames(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_ctecolnames();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_ctecolnames() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_ctecolnames();
  public:
  const ::pg_query::Node& ctecolnames(int index) const;
  ::pg_query::Node* add_ctecolnames();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      ctecolnames() const;
  // repeated .pg_query.Node ctecoltypes = 11 [json_name = "ctecoltypes"];
  int ctecoltypes_size() const;
  private:
  int _internal_ctecoltypes_size() const;

  public:
  void clear_ctecoltypes() ;
  ::pg_query::Node* mutable_ctecoltypes(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_ctecoltypes();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_ctecoltypes() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_ctecoltypes();
  public:
  const ::pg_query::Node& ctecoltypes(int index) const;
  ::pg_query::Node* add_ctecoltypes();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      ctecoltypes() const;
  // repeated .pg_query.Node ctecoltypmods = 12 [json_name = "ctecoltypmods"];
  int ctecoltypmods_size() const;
  private:
  int _internal_ctecoltypmods_size() const;

  public:
  void clear_ctecoltypmods() ;
  ::pg_query::Node* mutable_ctecoltypmods(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_ctecoltypmods();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_ctecoltypmods() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_ctecoltypmods();
  public:
  const ::pg_query::Node& ctecoltypmods(int index) const;
  ::pg_query::Node* add_ctecoltypmods();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      ctecoltypmods() const;
  // repeated .pg_query.Node ctecolcollations = 13 [json_name = "ctecolcollations"];
  int ctecolcollations_size() const;
  private:
  int _internal_ctecolcollations_size() const;

  public:
  void clear_ctecolcollations() ;
  ::pg_query::Node* mutable_ctecolcollations(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_ctecolcollations();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_ctecolcollations() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_ctecolcollations();
  public:
  const ::pg_query::Node& ctecolcollations(int index) const;
  ::pg_query::Node* add_ctecolcollations();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      ctecolcollations() const;
  // string ctename = 1 [json_name = "ctename"];
  void clear_ctename() ;
  const std::string& ctename() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_ctename(Arg_&& arg, Args_... args);
  std::string* mutable_ctename();
  PROTOBUF_NODISCARD std::string* release_ctename();
  void set_allocated_ctename(std::string* value);

  private:
  const std::string& _internal_ctename() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_ctequery() ;
  const ::pg_query::Node& ctequery() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_ctequery();
  ::pg_query::Node* mutable_ctequery();
  void set_allocated_ctequery(::pg_query::Node* value);
  void unsafe_arena_set_allocated_ctequery(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_ctequery();

  private:
  const ::pg_query::Node& _internal_ctequery() const;
  ::pg_query::Node* _internal_mutable_ctequery();

  public:
  // .pg_query.CTESearchClause search_clause = 5 [json_name = "search_clause"];
  bool has_search_clause() const;
  void clear_search_clause() ;
  const ::pg_query::CTESearchClause& search_clause() const;
  PROTOBUF_NODISCARD ::pg_query::CTESearchClause* release_search_clause();
  ::pg_query::CTESearchClause* mutable_search_clause();
  void set_allocated_search_clause(::pg_query::CTESearchClause* value);
  void unsafe_arena_set_allocated_search_clause(::pg_query::CTESearchClause* value);
  ::pg_query::CTESearchClause* unsafe_arena_release_search_clause();

  private:
  const ::pg_query::CTESearchClause& _internal_search_clause() const;
  ::pg_query::CTESearchClause* _internal_mutable_search_clause();

  public:
  // .pg_query.CTECycleClause cycle_clause = 6 [json_name = "cycle_clause"];
  bool has_cycle_clause() const;
  void clear_cycle_clause() ;
  const ::pg_query::CTECycleClause& cycle_clause() const;
  PROTOBUF_NODISCARD ::pg_query::CTECycleClause* release_cycle_clause();
  ::pg_query::CTECycleClause* mutable_cycle_clause();
  void set_allocated_cycle_clause(::pg_query::CTECycleClause* value);
  void unsafe_arena_set_allocated_cycle_clause(::pg_query::CTECycleClause* value);
  ::pg_query::CTECycleClause* unsafe_arena_release_cycle_clause();

  private:
  const ::pg_query::CTECycleClause& _internal_cycle_clause() const;
  ::pg_query::CTECycleClause* _internal_mutable_cycle_clause();

  public:
  // .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 = 7 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // bool cterecursive = 8 [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 = 9 [json_name = "cterefcount"];
  void clear_cterefcount() ;
  ::int32_t cterefcount() const;
  void set_cterefcount(::int32_t value);

  private:
  ::int32_t _internal_cterefcount() const;
  void _internal_set_cterefcount(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 13, 8,
      48, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > aliascolnames_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > ctecolnames_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > ctecoltypes_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > ctecoltypmods_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > ctecolcollations_;
    ::google::protobuf::internal::ArenaStringPtr ctename_;
    ::pg_query::Node* ctequery_;
    ::pg_query::CTESearchClause* search_clause_;
    ::pg_query::CTECycleClause* cycle_clause_;
    int ctematerialized_;
    ::int32_t location_;
    bool cterecursive_;
    ::int32_t cterefcount_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CompositeTypeStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CompositeTypeStmt) */ {
 public:
  inline CompositeTypeStmt() : CompositeTypeStmt(nullptr) {}
  ~CompositeTypeStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CompositeTypeStmt(::google::protobuf::internal::ConstantInitialized);

  inline CompositeTypeStmt(const CompositeTypeStmt& from)
      : CompositeTypeStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CompositeTypeStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CompositeTypeStmt* internal_default_instance() {
    return reinterpret_cast<const CompositeTypeStmt*>(
               &_CompositeTypeStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    215;

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

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

  CompositeTypeStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CompositeTypeStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CompositeTypeStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CompositeTypeStmt& from) {
    CompositeTypeStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CompositeTypeStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CompositeTypeStmt";
  }
  protected:
  explicit CompositeTypeStmt(::google::protobuf::Arena* arena);
  CompositeTypeStmt(::google::protobuf::Arena* arena, const CompositeTypeStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_coldeflist();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_coldeflist() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_coldeflist();
  public:
  const ::pg_query::Node& coldeflist(int index) const;
  ::pg_query::Node* add_coldeflist();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      coldeflist() const;
  // .pg_query.RangeVar typevar = 1 [json_name = "typevar"];
  bool has_typevar() const;
  void clear_typevar() ;
  const ::pg_query::RangeVar& typevar() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_typevar();
  ::pg_query::RangeVar* mutable_typevar();
  void set_allocated_typevar(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_typevar(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_typevar();

  private:
  const ::pg_query::RangeVar& _internal_typevar() const;
  ::pg_query::RangeVar* _internal_mutable_typevar();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > coldeflist_;
    ::pg_query::RangeVar* typevar_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class Constraint final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.Constraint) */ {
 public:
  inline Constraint() : Constraint(nullptr) {}
  ~Constraint() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Constraint(::google::protobuf::internal::ConstantInitialized);

  inline Constraint(const Constraint& from)
      : Constraint(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Constraint& default_instance() {
    return *internal_default_instance();
  }
  static inline const Constraint* internal_default_instance() {
    return reinterpret_cast<const Constraint*>(
               &_Constraint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    150;

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

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

  Constraint* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Constraint>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Constraint& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const Constraint& from) {
    Constraint::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(Constraint* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.Constraint";
  }
  protected:
  explicit Constraint(::google::protobuf::Arena* arena);
  Constraint(::google::protobuf::Arena* arena, const Constraint& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kKeysFieldNumber = 11,
    kIncludingFieldNumber = 12,
    kExclusionsFieldNumber = 13,
    kOptionsFieldNumber = 14,
    kFkAttrsFieldNumber = 21,
    kPkAttrsFieldNumber = 22,
    kFkDelSetColsFieldNumber = 26,
    kOldConpfeqopFieldNumber = 27,
    kConnameFieldNumber = 2,
    kCookedExprFieldNumber = 8,
    kGeneratedWhenFieldNumber = 9,
    kIndexnameFieldNumber = 15,
    kIndexspaceFieldNumber = 16,
    kAccessMethodFieldNumber = 18,
    kFkMatchtypeFieldNumber = 23,
    kFkUpdActionFieldNumber = 24,
    kFkDelActionFieldNumber = 25,
    kRawExprFieldNumber = 7,
    kWhereClauseFieldNumber = 19,
    kPktableFieldNumber = 20,
    kContypeFieldNumber = 1,
    kLocationFieldNumber = 5,
    kDeferrableFieldNumber = 3,
    kInitdeferredFieldNumber = 4,
    kIsNoInheritFieldNumber = 6,
    kNullsNotDistinctFieldNumber = 10,
    kResetDefaultTblspcFieldNumber = 17,
    kSkipValidationFieldNumber = 29,
    kInitiallyValidFieldNumber = 30,
    kOldPktableOidFieldNumber = 28,
  };
  // repeated .pg_query.Node keys = 11 [json_name = "keys"];
  int keys_size() const;
  private:
  int _internal_keys_size() const;

  public:
  void clear_keys() ;
  ::pg_query::Node* mutable_keys(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_keys();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_keys() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_keys();
  public:
  const ::pg_query::Node& keys(int index) const;
  ::pg_query::Node* add_keys();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      keys() const;
  // repeated .pg_query.Node including = 12 [json_name = "including"];
  int including_size() const;
  private:
  int _internal_including_size() const;

  public:
  void clear_including() ;
  ::pg_query::Node* mutable_including(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_including();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_including() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_including();
  public:
  const ::pg_query::Node& including(int index) const;
  ::pg_query::Node* add_including();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      including() const;
  // repeated .pg_query.Node exclusions = 13 [json_name = "exclusions"];
  int exclusions_size() const;
  private:
  int _internal_exclusions_size() const;

  public:
  void clear_exclusions() ;
  ::pg_query::Node* mutable_exclusions(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_exclusions();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_exclusions() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_exclusions();
  public:
  const ::pg_query::Node& exclusions(int index) const;
  ::pg_query::Node* add_exclusions();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      exclusions() const;
  // repeated .pg_query.Node options = 14 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;

  public:
  void clear_options() ;
  ::pg_query::Node* mutable_options(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // repeated .pg_query.Node fk_attrs = 21 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_fk_attrs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_fk_attrs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_fk_attrs();
  public:
  const ::pg_query::Node& fk_attrs(int index) const;
  ::pg_query::Node* add_fk_attrs();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      fk_attrs() const;
  // repeated .pg_query.Node pk_attrs = 22 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_pk_attrs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_pk_attrs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_pk_attrs();
  public:
  const ::pg_query::Node& pk_attrs(int index) const;
  ::pg_query::Node* add_pk_attrs();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      pk_attrs() const;
  // repeated .pg_query.Node fk_del_set_cols = 26 [json_name = "fk_del_set_cols"];
  int fk_del_set_cols_size() const;
  private:
  int _internal_fk_del_set_cols_size() const;

  public:
  void clear_fk_del_set_cols() ;
  ::pg_query::Node* mutable_fk_del_set_cols(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_fk_del_set_cols();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_fk_del_set_cols() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_fk_del_set_cols();
  public:
  const ::pg_query::Node& fk_del_set_cols(int index) const;
  ::pg_query::Node* add_fk_del_set_cols();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      fk_del_set_cols() const;
  // repeated .pg_query.Node old_conpfeqop = 27 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_old_conpfeqop();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_old_conpfeqop() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_old_conpfeqop();
  public:
  const ::pg_query::Node& old_conpfeqop(int index) const;
  ::pg_query::Node* add_old_conpfeqop();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      old_conpfeqop() const;
  // string conname = 2 [json_name = "conname"];
  void clear_conname() ;
  const std::string& conname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_conname(Arg_&& arg, Args_... args);
  std::string* mutable_conname();
  PROTOBUF_NODISCARD std::string* release_conname();
  void set_allocated_conname(std::string* value);

  private:
  const std::string& _internal_conname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_cooked_expr(Arg_&& arg, Args_... args);
  std::string* mutable_cooked_expr();
  PROTOBUF_NODISCARD std::string* release_cooked_expr();
  void set_allocated_cooked_expr(std::string* value);

  private:
  const std::string& _internal_cooked_expr() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_generated_when(Arg_&& arg, Args_... args);
  std::string* mutable_generated_when();
  PROTOBUF_NODISCARD std::string* release_generated_when();
  void set_allocated_generated_when(std::string* value);

  private:
  const std::string& _internal_generated_when() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_generated_when(
      const std::string& value);
  std::string* _internal_mutable_generated_when();

  public:
  // string indexname = 15 [json_name = "indexname"];
  void clear_indexname() ;
  const std::string& indexname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_indexname(Arg_&& arg, Args_... args);
  std::string* mutable_indexname();
  PROTOBUF_NODISCARD std::string* release_indexname();
  void set_allocated_indexname(std::string* value);

  private:
  const std::string& _internal_indexname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_indexname(
      const std::string& value);
  std::string* _internal_mutable_indexname();

  public:
  // string indexspace = 16 [json_name = "indexspace"];
  void clear_indexspace() ;
  const std::string& indexspace() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_indexspace(Arg_&& arg, Args_... args);
  std::string* mutable_indexspace();
  PROTOBUF_NODISCARD std::string* release_indexspace();
  void set_allocated_indexspace(std::string* value);

  private:
  const std::string& _internal_indexspace() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_indexspace(
      const std::string& value);
  std::string* _internal_mutable_indexspace();

  public:
  // string access_method = 18 [json_name = "access_method"];
  void clear_access_method() ;
  const std::string& access_method() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_access_method(Arg_&& arg, Args_... args);
  std::string* mutable_access_method();
  PROTOBUF_NODISCARD std::string* release_access_method();
  void set_allocated_access_method(std::string* value);

  private:
  const std::string& _internal_access_method() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_access_method(
      const std::string& value);
  std::string* _internal_mutable_access_method();

  public:
  // string fk_matchtype = 23 [json_name = "fk_matchtype"];
  void clear_fk_matchtype() ;
  const std::string& fk_matchtype() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_fk_matchtype(Arg_&& arg, Args_... args);
  std::string* mutable_fk_matchtype();
  PROTOBUF_NODISCARD std::string* release_fk_matchtype();
  void set_allocated_fk_matchtype(std::string* value);

  private:
  const std::string& _internal_fk_matchtype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fk_matchtype(
      const std::string& value);
  std::string* _internal_mutable_fk_matchtype();

  public:
  // string fk_upd_action = 24 [json_name = "fk_upd_action"];
  void clear_fk_upd_action() ;
  const std::string& fk_upd_action() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_fk_upd_action(Arg_&& arg, Args_... args);
  std::string* mutable_fk_upd_action();
  PROTOBUF_NODISCARD std::string* release_fk_upd_action();
  void set_allocated_fk_upd_action(std::string* value);

  private:
  const std::string& _internal_fk_upd_action() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fk_upd_action(
      const std::string& value);
  std::string* _internal_mutable_fk_upd_action();

  public:
  // string fk_del_action = 25 [json_name = "fk_del_action"];
  void clear_fk_del_action() ;
  const std::string& fk_del_action() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_fk_del_action(Arg_&& arg, Args_... args);
  std::string* mutable_fk_del_action();
  PROTOBUF_NODISCARD std::string* release_fk_del_action();
  void set_allocated_fk_del_action(std::string* value);

  private:
  const std::string& _internal_fk_del_action() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_raw_expr() ;
  const ::pg_query::Node& raw_expr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_raw_expr();
  ::pg_query::Node* mutable_raw_expr();
  void set_allocated_raw_expr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_raw_expr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_raw_expr();

  private:
  const ::pg_query::Node& _internal_raw_expr() const;
  ::pg_query::Node* _internal_mutable_raw_expr();

  public:
  // .pg_query.Node where_clause = 19 [json_name = "where_clause"];
  bool has_where_clause() const;
  void clear_where_clause() ;
  const ::pg_query::Node& where_clause() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* value);
  void unsafe_arena_set_allocated_where_clause(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();

  public:
  // .pg_query.RangeVar pktable = 20 [json_name = "pktable"];
  bool has_pktable() const;
  void clear_pktable() ;
  const ::pg_query::RangeVar& pktable() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_pktable();
  ::pg_query::RangeVar* mutable_pktable();
  void set_allocated_pktable(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_pktable(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_pktable();

  private:
  const ::pg_query::RangeVar& _internal_pktable() const;
  ::pg_query::RangeVar* _internal_mutable_pktable();

  public:
  // .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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t 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 nulls_not_distinct = 10 [json_name = "nulls_not_distinct"];
  void clear_nulls_not_distinct() ;
  bool nulls_not_distinct() const;
  void set_nulls_not_distinct(bool value);

  private:
  bool _internal_nulls_not_distinct() const;
  void _internal_set_nulls_not_distinct(bool value);

  public:
  // bool reset_default_tblspc = 17 [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:
  // bool skip_validation = 29 [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 = 30 [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:
  // uint32 old_pktable_oid = 28 [json_name = "old_pktable_oid"];
  void clear_old_pktable_oid() ;
  ::uint32_t old_pktable_oid() const;
  void set_old_pktable_oid(::uint32_t value);

  private:
  ::uint32_t _internal_old_pktable_oid() const;
  void _internal_set_old_pktable_oid(::uint32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      5, 30, 11,
      154, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > keys_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > including_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > exclusions_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > fk_attrs_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > pk_attrs_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > fk_del_set_cols_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > old_conpfeqop_;
    ::google::protobuf::internal::ArenaStringPtr conname_;
    ::google::protobuf::internal::ArenaStringPtr cooked_expr_;
    ::google::protobuf::internal::ArenaStringPtr generated_when_;
    ::google::protobuf::internal::ArenaStringPtr indexname_;
    ::google::protobuf::internal::ArenaStringPtr indexspace_;
    ::google::protobuf::internal::ArenaStringPtr access_method_;
    ::google::protobuf::internal::ArenaStringPtr fk_matchtype_;
    ::google::protobuf::internal::ArenaStringPtr fk_upd_action_;
    ::google::protobuf::internal::ArenaStringPtr fk_del_action_;
    ::pg_query::Node* raw_expr_;
    ::pg_query::Node* where_clause_;
    ::pg_query::RangeVar* pktable_;
    int contype_;
    ::int32_t location_;
    bool deferrable_;
    bool initdeferred_;
    bool is_no_inherit_;
    bool nulls_not_distinct_;
    bool reset_default_tblspc_;
    bool skip_validation_;
    bool initially_valid_;
    ::uint32_t old_pktable_oid_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ConstraintsSetStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ConstraintsSetStmt) */ {
 public:
  inline ConstraintsSetStmt() : ConstraintsSetStmt(nullptr) {}
  ~ConstraintsSetStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ConstraintsSetStmt(::google::protobuf::internal::ConstantInitialized);

  inline ConstraintsSetStmt(const ConstraintsSetStmt& from)
      : ConstraintsSetStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ConstraintsSetStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ConstraintsSetStmt* internal_default_instance() {
    return reinterpret_cast<const ConstraintsSetStmt*>(
               &_ConstraintsSetStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    236;

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

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

  ConstraintsSetStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ConstraintsSetStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ConstraintsSetStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ConstraintsSetStmt& from) {
    ConstraintsSetStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ConstraintsSetStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ConstraintsSetStmt";
  }
  protected:
  explicit ConstraintsSetStmt(::google::protobuf::Arena* arena);
  ConstraintsSetStmt(::google::protobuf::Arena* arena, const ConstraintsSetStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_constraints();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_constraints() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_constraints();
  public:
  const ::pg_query::Node& constraints(int index) const;
  ::pg_query::Node* add_constraints();
  const ::google::protobuf::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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > constraints_;
    bool deferred_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ConvertRowtypeExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ConvertRowtypeExpr) */ {
 public:
  inline ConvertRowtypeExpr() : ConvertRowtypeExpr(nullptr) {}
  ~ConvertRowtypeExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ConvertRowtypeExpr(::google::protobuf::internal::ConstantInitialized);

  inline ConvertRowtypeExpr(const ConvertRowtypeExpr& from)
      : ConvertRowtypeExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ConvertRowtypeExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConvertRowtypeExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ConvertRowtypeExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ConvertRowtypeExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ConvertRowtypeExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ConvertRowtypeExpr& from) {
    ConvertRowtypeExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ConvertRowtypeExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ConvertRowtypeExpr";
  }
  protected:
  explicit ConvertRowtypeExpr(::google::protobuf::Arena* arena);
  ConvertRowtypeExpr(::google::protobuf::Arena* arena, const ConvertRowtypeExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

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

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // uint32 resulttype = 3 [json_name = "resulttype"];
  void clear_resulttype() ;
  ::uint32_t resulttype() const;
  void set_resulttype(::uint32_t value);

  private:
  ::uint32_t _internal_resulttype() const;
  void _internal_set_resulttype(::uint32_t 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* arg_;
    ::uint32_t resulttype_;
    int convertformat_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CopyStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CopyStmt) */ {
 public:
  inline CopyStmt() : CopyStmt(nullptr) {}
  ~CopyStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CopyStmt(::google::protobuf::internal::ConstantInitialized);

  inline CopyStmt(const CopyStmt& from)
      : CopyStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CopyStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CopyStmt* internal_default_instance() {
    return reinterpret_cast<const CopyStmt*>(
               &_CopyStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    146;

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

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

  CopyStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CopyStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CopyStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CopyStmt& from) {
    CopyStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CopyStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CopyStmt";
  }
  protected:
  explicit CopyStmt(::google::protobuf::Arena* arena);
  CopyStmt(::google::protobuf::Arena* arena, const CopyStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_attlist();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_attlist() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_attlist();
  public:
  const ::pg_query::Node& attlist(int index) const;
  ::pg_query::Node* add_attlist();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string filename = 6 [json_name = "filename"];
  void clear_filename() ;
  const std::string& filename() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_filename(Arg_&& arg, Args_... args);
  std::string* mutable_filename();
  PROTOBUF_NODISCARD std::string* release_filename();
  void set_allocated_filename(std::string* value);

  private:
  const std::string& _internal_filename() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node query = 2 [json_name = "query"];
  bool has_query() const;
  void clear_query() ;
  const ::pg_query::Node& query() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* value);
  void unsafe_arena_set_allocated_query(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_query();

  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();

  public:
  // .pg_query.Node where_clause = 8 [json_name = "whereClause"];
  bool has_where_clause() const;
  void clear_where_clause() ;
  const ::pg_query::Node& where_clause() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* value);
  void unsafe_arena_set_allocated_where_clause(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 5,
      42, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > attlist_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr filename_;
    ::pg_query::RangeVar* relation_;
    ::pg_query::Node* query_;
    ::pg_query::Node* where_clause_;
    bool is_from_;
    bool is_program_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateAmStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateAmStmt) */ {
 public:
  inline CreateAmStmt() : CreateAmStmt(nullptr) {}
  ~CreateAmStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateAmStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateAmStmt(const CreateAmStmt& from)
      : CreateAmStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateAmStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateAmStmt* internal_default_instance() {
    return reinterpret_cast<const CreateAmStmt*>(
               &_CreateAmStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    169;

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

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

  CreateAmStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateAmStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateAmStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateAmStmt& from) {
    CreateAmStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateAmStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateAmStmt";
  }
  protected:
  explicit CreateAmStmt(::google::protobuf::Arena* arena);
  CreateAmStmt(::google::protobuf::Arena* arena, const CreateAmStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_handler_name();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_handler_name() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_handler_name();
  public:
  const ::pg_query::Node& handler_name(int index) const;
  ::pg_query::Node* add_handler_name();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      handler_name() const;
  // string amname = 1 [json_name = "amname"];
  void clear_amname() ;
  const std::string& amname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_amname(Arg_&& arg, Args_... args);
  std::string* mutable_amname();
  PROTOBUF_NODISCARD std::string* release_amname();
  void set_allocated_amname(std::string* value);

  private:
  const std::string& _internal_amname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_amtype(Arg_&& arg, Args_... args);
  std::string* mutable_amtype();
  PROTOBUF_NODISCARD std::string* release_amtype();
  void set_allocated_amtype(std::string* value);

  private:
  const std::string& _internal_amtype() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      42, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > handler_name_;
    ::google::protobuf::internal::ArenaStringPtr amname_;
    ::google::protobuf::internal::ArenaStringPtr amtype_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateCastStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateCastStmt) */ {
 public:
  inline CreateCastStmt() : CreateCastStmt(nullptr) {}
  ~CreateCastStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateCastStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateCastStmt(const CreateCastStmt& from)
      : CreateCastStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateCastStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateCastStmt* internal_default_instance() {
    return reinterpret_cast<const CreateCastStmt*>(
               &_CreateCastStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    239;

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

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

  CreateCastStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateCastStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateCastStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateCastStmt& from) {
    CreateCastStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateCastStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateCastStmt";
  }
  protected:
  explicit CreateCastStmt(::google::protobuf::Arena* arena);
  CreateCastStmt(::google::protobuf::Arena* arena, const CreateCastStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_sourcetype() ;
  const ::pg_query::TypeName& sourcetype() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_sourcetype();
  ::pg_query::TypeName* mutable_sourcetype();
  void set_allocated_sourcetype(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_sourcetype(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_sourcetype();

  private:
  const ::pg_query::TypeName& _internal_sourcetype() const;
  ::pg_query::TypeName* _internal_mutable_sourcetype();

  public:
  // .pg_query.TypeName targettype = 2 [json_name = "targettype"];
  bool has_targettype() const;
  void clear_targettype() ;
  const ::pg_query::TypeName& targettype() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_targettype();
  ::pg_query::TypeName* mutable_targettype();
  void set_allocated_targettype(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_targettype(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_targettype();

  private:
  const ::pg_query::TypeName& _internal_targettype() const;
  ::pg_query::TypeName* _internal_mutable_targettype();

  public:
  // .pg_query.ObjectWithArgs func = 3 [json_name = "func"];
  bool has_func() const;
  void clear_func() ;
  const ::pg_query::ObjectWithArgs& func() const;
  PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_func();
  ::pg_query::ObjectWithArgs* mutable_func();
  void set_allocated_func(::pg_query::ObjectWithArgs* value);
  void unsafe_arena_set_allocated_func(::pg_query::ObjectWithArgs* value);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_func();

  private:
  const ::pg_query::ObjectWithArgs& _internal_func() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_func();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::TypeName* sourcetype_;
    ::pg_query::TypeName* targettype_;
    ::pg_query::ObjectWithArgs* func_;
    int context_;
    bool inout_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateConversionStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateConversionStmt) */ {
 public:
  inline CreateConversionStmt() : CreateConversionStmt(nullptr) {}
  ~CreateConversionStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateConversionStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateConversionStmt(const CreateConversionStmt& from)
      : CreateConversionStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateConversionStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateConversionStmt* internal_default_instance() {
    return reinterpret_cast<const CreateConversionStmt*>(
               &_CreateConversionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    238;

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

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

  CreateConversionStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateConversionStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateConversionStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateConversionStmt& from) {
    CreateConversionStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateConversionStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateConversionStmt";
  }
  protected:
  explicit CreateConversionStmt(::google::protobuf::Arena* arena);
  CreateConversionStmt(::google::protobuf::Arena* arena, const CreateConversionStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_conversion_name();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_conversion_name() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_conversion_name();
  public:
  const ::pg_query::Node& conversion_name(int index) const;
  ::pg_query::Node* add_conversion_name();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_func_name();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_func_name() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_func_name();
  public:
  const ::pg_query::Node& func_name(int index) const;
  ::pg_query::Node* add_func_name();
  const ::google::protobuf::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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_for_encoding_name(Arg_&& arg, Args_... args);
  std::string* mutable_for_encoding_name();
  PROTOBUF_NODISCARD std::string* release_for_encoding_name();
  void set_allocated_for_encoding_name(std::string* value);

  private:
  const std::string& _internal_for_encoding_name() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_to_encoding_name(Arg_&& arg, Args_... args);
  std::string* mutable_to_encoding_name();
  PROTOBUF_NODISCARD std::string* release_to_encoding_name();
  void set_allocated_to_encoding_name(std::string* value);

  private:
  const std::string& _internal_to_encoding_name() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      71, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > conversion_name_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > func_name_;
    ::google::protobuf::internal::ArenaStringPtr for_encoding_name_;
    ::google::protobuf::internal::ArenaStringPtr to_encoding_name_;
    bool def_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateDomainStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateDomainStmt) */ {
 public:
  inline CreateDomainStmt() : CreateDomainStmt(nullptr) {}
  ~CreateDomainStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateDomainStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateDomainStmt(const CreateDomainStmt& from)
      : CreateDomainStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateDomainStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateDomainStmt* internal_default_instance() {
    return reinterpret_cast<const CreateDomainStmt*>(
               &_CreateDomainStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    181;

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

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

  CreateDomainStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateDomainStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateDomainStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateDomainStmt& from) {
    CreateDomainStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateDomainStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateDomainStmt";
  }
  protected:
  explicit CreateDomainStmt(::google::protobuf::Arena* arena);
  CreateDomainStmt(::google::protobuf::Arena* arena, const CreateDomainStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_domainname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_domainname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_domainname();
  public:
  const ::pg_query::Node& domainname(int index) const;
  ::pg_query::Node* add_domainname();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_constraints();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_constraints() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_constraints();
  public:
  const ::pg_query::Node& constraints(int index) const;
  ::pg_query::Node* add_constraints();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      constraints() const;
  // .pg_query.TypeName type_name = 2 [json_name = "typeName"];
  bool has_type_name() const;
  void clear_type_name() ;
  const ::pg_query::TypeName& type_name() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_type_name(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();

  public:
  // .pg_query.CollateClause coll_clause = 3 [json_name = "collClause"];
  bool has_coll_clause() const;
  void clear_coll_clause() ;
  const ::pg_query::CollateClause& coll_clause() const;
  PROTOBUF_NODISCARD ::pg_query::CollateClause* release_coll_clause();
  ::pg_query::CollateClause* mutable_coll_clause();
  void set_allocated_coll_clause(::pg_query::CollateClause* value);
  void unsafe_arena_set_allocated_coll_clause(::pg_query::CollateClause* value);
  ::pg_query::CollateClause* unsafe_arena_release_coll_clause();

  private:
  const ::pg_query::CollateClause& _internal_coll_clause() const;
  ::pg_query::CollateClause* _internal_mutable_coll_clause();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 4,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > domainname_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > constraints_;
    ::pg_query::TypeName* type_name_;
    ::pg_query::CollateClause* coll_clause_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateEnumStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateEnumStmt) */ {
 public:
  inline CreateEnumStmt() : CreateEnumStmt(nullptr) {}
  ~CreateEnumStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateEnumStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateEnumStmt(const CreateEnumStmt& from)
      : CreateEnumStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateEnumStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateEnumStmt* internal_default_instance() {
    return reinterpret_cast<const CreateEnumStmt*>(
               &_CreateEnumStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    216;

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

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

  CreateEnumStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateEnumStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateEnumStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateEnumStmt& from) {
    CreateEnumStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateEnumStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateEnumStmt";
  }
  protected:
  explicit CreateEnumStmt(::google::protobuf::Arena* arena);
  CreateEnumStmt(::google::protobuf::Arena* arena, const CreateEnumStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_type_name();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_type_name() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_type_name();
  public:
  const ::pg_query::Node& type_name(int index) const;
  ::pg_query::Node* add_type_name();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_vals();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_vals() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_vals();
  public:
  const ::pg_query::Node& vals(int index) const;
  ::pg_query::Node* add_vals();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      vals() const;
  // @@protoc_insertion_point(class_scope:pg_query.CreateEnumStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > type_name_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > vals_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateEventTrigStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateEventTrigStmt) */ {
 public:
  inline CreateEventTrigStmt() : CreateEventTrigStmt(nullptr) {}
  ~CreateEventTrigStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateEventTrigStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateEventTrigStmt(const CreateEventTrigStmt& from)
      : CreateEventTrigStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateEventTrigStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateEventTrigStmt* internal_default_instance() {
    return reinterpret_cast<const CreateEventTrigStmt*>(
               &_CreateEventTrigStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    171;

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

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

  CreateEventTrigStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateEventTrigStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateEventTrigStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateEventTrigStmt& from) {
    CreateEventTrigStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateEventTrigStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateEventTrigStmt";
  }
  protected:
  explicit CreateEventTrigStmt(::google::protobuf::Arena* arena);
  CreateEventTrigStmt(::google::protobuf::Arena* arena, const CreateEventTrigStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_whenclause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_whenclause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_whenclause();
  public:
  const ::pg_query::Node& whenclause(int index) const;
  ::pg_query::Node* add_whenclause();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_funcname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_funcname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_funcname();
  public:
  const ::pg_query::Node& funcname(int index) const;
  ::pg_query::Node* add_funcname();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      funcname() const;
  // string trigname = 1 [json_name = "trigname"];
  void clear_trigname() ;
  const std::string& trigname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_trigname(Arg_&& arg, Args_... args);
  std::string* mutable_trigname();
  PROTOBUF_NODISCARD std::string* release_trigname();
  void set_allocated_trigname(std::string* value);

  private:
  const std::string& _internal_trigname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_eventname(Arg_&& arg, Args_... args);
  std::string* mutable_eventname();
  PROTOBUF_NODISCARD std::string* release_eventname();
  void set_allocated_eventname(std::string* value);

  private:
  const std::string& _internal_eventname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      54, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > whenclause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > funcname_;
    ::google::protobuf::internal::ArenaStringPtr trigname_;
    ::google::protobuf::internal::ArenaStringPtr eventname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateExtensionStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateExtensionStmt) */ {
 public:
  inline CreateExtensionStmt() : CreateExtensionStmt(nullptr) {}
  ~CreateExtensionStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateExtensionStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateExtensionStmt(const CreateExtensionStmt& from)
      : CreateExtensionStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateExtensionStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateExtensionStmt* internal_default_instance() {
    return reinterpret_cast<const CreateExtensionStmt*>(
               &_CreateExtensionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    155;

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

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

  CreateExtensionStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateExtensionStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateExtensionStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateExtensionStmt& from) {
    CreateExtensionStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateExtensionStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateExtensionStmt";
  }
  protected:
  explicit CreateExtensionStmt(::google::protobuf::Arena* arena);
  CreateExtensionStmt(::google::protobuf::Arena* arena, const CreateExtensionStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string extname = 1 [json_name = "extname"];
  void clear_extname() ;
  const std::string& extname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_extname(Arg_&& arg, Args_... args);
  std::string* mutable_extname();
  PROTOBUF_NODISCARD std::string* release_extname();
  void set_allocated_extname(std::string* value);

  private:
  const std::string& _internal_extname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      44, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr extname_;
    bool if_not_exists_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateFdwStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateFdwStmt) */ {
 public:
  inline CreateFdwStmt() : CreateFdwStmt(nullptr) {}
  ~CreateFdwStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateFdwStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateFdwStmt(const CreateFdwStmt& from)
      : CreateFdwStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateFdwStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateFdwStmt* internal_default_instance() {
    return reinterpret_cast<const CreateFdwStmt*>(
               &_CreateFdwStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    158;

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

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

  CreateFdwStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateFdwStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateFdwStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateFdwStmt& from) {
    CreateFdwStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateFdwStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateFdwStmt";
  }
  protected:
  explicit CreateFdwStmt(::google::protobuf::Arena* arena);
  CreateFdwStmt(::google::protobuf::Arena* arena, const CreateFdwStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_func_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_func_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_func_options();
  public:
  const ::pg_query::Node& func_options(int index) const;
  ::pg_query::Node* add_func_options();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string fdwname = 1 [json_name = "fdwname"];
  void clear_fdwname() ;
  const std::string& fdwname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_fdwname(Arg_&& arg, Args_... args);
  std::string* mutable_fdwname();
  PROTOBUF_NODISCARD std::string* release_fdwname();
  void set_allocated_fdwname(std::string* value);

  private:
  const std::string& _internal_fdwname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      38, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > func_options_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr fdwname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateForeignServerStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateForeignServerStmt) */ {
 public:
  inline CreateForeignServerStmt() : CreateForeignServerStmt(nullptr) {}
  ~CreateForeignServerStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateForeignServerStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateForeignServerStmt(const CreateForeignServerStmt& from)
      : CreateForeignServerStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateForeignServerStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateForeignServerStmt* internal_default_instance() {
    return reinterpret_cast<const CreateForeignServerStmt*>(
               &_CreateForeignServerStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    160;

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

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

  CreateForeignServerStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateForeignServerStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateForeignServerStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateForeignServerStmt& from) {
    CreateForeignServerStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateForeignServerStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateForeignServerStmt";
  }
  protected:
  explicit CreateForeignServerStmt(::google::protobuf::Arena* arena);
  CreateForeignServerStmt(::google::protobuf::Arena* arena, const CreateForeignServerStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string servername = 1 [json_name = "servername"];
  void clear_servername() ;
  const std::string& servername() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_servername(Arg_&& arg, Args_... args);
  std::string* mutable_servername();
  PROTOBUF_NODISCARD std::string* release_servername();
  void set_allocated_servername(std::string* value);

  private:
  const std::string& _internal_servername() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_servertype(Arg_&& arg, Args_... args);
  std::string* mutable_servertype();
  PROTOBUF_NODISCARD std::string* release_servertype();
  void set_allocated_servertype(std::string* value);

  private:
  const std::string& _internal_servertype() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_version(Arg_&& arg, Args_... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* value);

  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_fdwname(Arg_&& arg, Args_... args);
  std::string* mutable_fdwname();
  PROTOBUF_NODISCARD std::string* release_fdwname();
  void set_allocated_fdwname(std::string* value);

  private:
  const std::string& _internal_fdwname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 1,
      75, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr servername_;
    ::google::protobuf::internal::ArenaStringPtr servertype_;
    ::google::protobuf::internal::ArenaStringPtr version_;
    ::google::protobuf::internal::ArenaStringPtr fdwname_;
    bool if_not_exists_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateForeignTableStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateForeignTableStmt) */ {
 public:
  inline CreateForeignTableStmt() : CreateForeignTableStmt(nullptr) {}
  ~CreateForeignTableStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateForeignTableStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateForeignTableStmt(const CreateForeignTableStmt& from)
      : CreateForeignTableStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateForeignTableStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateForeignTableStmt* internal_default_instance() {
    return reinterpret_cast<const CreateForeignTableStmt*>(
               &_CreateForeignTableStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    162;

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

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

  CreateForeignTableStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateForeignTableStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateForeignTableStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateForeignTableStmt& from) {
    CreateForeignTableStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateForeignTableStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateForeignTableStmt";
  }
  protected:
  explicit CreateForeignTableStmt(::google::protobuf::Arena* arena);
  CreateForeignTableStmt(::google::protobuf::Arena* arena, const CreateForeignTableStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string servername = 2 [json_name = "servername"];
  void clear_servername() ;
  const std::string& servername() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_servername(Arg_&& arg, Args_... args);
  std::string* mutable_servername();
  PROTOBUF_NODISCARD std::string* release_servername();
  void set_allocated_servername(std::string* value);

  private:
  const std::string& _internal_servername() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_base_stmt() ;
  const ::pg_query::CreateStmt& base_stmt() const;
  PROTOBUF_NODISCARD ::pg_query::CreateStmt* release_base_stmt();
  ::pg_query::CreateStmt* mutable_base_stmt();
  void set_allocated_base_stmt(::pg_query::CreateStmt* value);
  void unsafe_arena_set_allocated_base_stmt(::pg_query::CreateStmt* value);
  ::pg_query::CreateStmt* unsafe_arena_release_base_stmt();

  private:
  const ::pg_query::CreateStmt& _internal_base_stmt() const;
  ::pg_query::CreateStmt* _internal_mutable_base_stmt();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      50, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr servername_;
    ::pg_query::CreateStmt* base_stmt_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateFunctionStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateFunctionStmt) */ {
 public:
  inline CreateFunctionStmt() : CreateFunctionStmt(nullptr) {}
  ~CreateFunctionStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateFunctionStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateFunctionStmt(const CreateFunctionStmt& from)
      : CreateFunctionStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateFunctionStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateFunctionStmt* internal_default_instance() {
    return reinterpret_cast<const CreateFunctionStmt*>(
               &_CreateFunctionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    197;

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

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

  CreateFunctionStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateFunctionStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateFunctionStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateFunctionStmt& from) {
    CreateFunctionStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateFunctionStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateFunctionStmt";
  }
  protected:
  explicit CreateFunctionStmt(::google::protobuf::Arena* arena);
  CreateFunctionStmt(::google::protobuf::Arena* arena, const CreateFunctionStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kFuncnameFieldNumber = 3,
    kParametersFieldNumber = 4,
    kOptionsFieldNumber = 6,
    kReturnTypeFieldNumber = 5,
    kSqlBodyFieldNumber = 7,
    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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_funcname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_funcname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_funcname();
  public:
  const ::pg_query::Node& funcname(int index) const;
  ::pg_query::Node* add_funcname();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_parameters();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_parameters() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_parameters();
  public:
  const ::pg_query::Node& parameters(int index) const;
  ::pg_query::Node* add_parameters();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // .pg_query.TypeName return_type = 5 [json_name = "returnType"];
  bool has_return_type() const;
  void clear_return_type() ;
  const ::pg_query::TypeName& return_type() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_return_type();
  ::pg_query::TypeName* mutable_return_type();
  void set_allocated_return_type(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_return_type(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_return_type();

  private:
  const ::pg_query::TypeName& _internal_return_type() const;
  ::pg_query::TypeName* _internal_mutable_return_type();

  public:
  // .pg_query.Node sql_body = 7 [json_name = "sql_body"];
  bool has_sql_body() const;
  void clear_sql_body() ;
  const ::pg_query::Node& sql_body() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_sql_body();
  ::pg_query::Node* mutable_sql_body();
  void set_allocated_sql_body(::pg_query::Node* value);
  void unsafe_arena_set_allocated_sql_body(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_sql_body();

  private:
  const ::pg_query::Node& _internal_sql_body() const;
  ::pg_query::Node* _internal_mutable_sql_body();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 5,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > funcname_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > parameters_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::pg_query::TypeName* return_type_;
    ::pg_query::Node* sql_body_;
    bool is_procedure_;
    bool replace_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateOpClassItem final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateOpClassItem) */ {
 public:
  inline CreateOpClassItem() : CreateOpClassItem(nullptr) {}
  ~CreateOpClassItem() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateOpClassItem(::google::protobuf::internal::ConstantInitialized);

  inline CreateOpClassItem(const CreateOpClassItem& from)
      : CreateOpClassItem(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateOpClassItem& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateOpClassItem* internal_default_instance() {
    return reinterpret_cast<const CreateOpClassItem*>(
               &_CreateOpClassItem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    183;

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

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

  CreateOpClassItem* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateOpClassItem>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateOpClassItem& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateOpClassItem& from) {
    CreateOpClassItem::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateOpClassItem* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateOpClassItem";
  }
  protected:
  explicit CreateOpClassItem(::google::protobuf::Arena* arena);
  CreateOpClassItem(::google::protobuf::Arena* arena, const CreateOpClassItem& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_order_family();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_order_family() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_order_family();
  public:
  const ::pg_query::Node& order_family(int index) const;
  ::pg_query::Node* add_order_family();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_class_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_class_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_class_args();
  public:
  const ::pg_query::Node& class_args(int index) const;
  ::pg_query::Node* add_class_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      class_args() const;
  // .pg_query.ObjectWithArgs name = 2 [json_name = "name"];
  bool has_name() const;
  void clear_name() ;
  const ::pg_query::ObjectWithArgs& name() const;
  PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_name();
  ::pg_query::ObjectWithArgs* mutable_name();
  void set_allocated_name(::pg_query::ObjectWithArgs* value);
  void unsafe_arena_set_allocated_name(::pg_query::ObjectWithArgs* value);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_name();

  private:
  const ::pg_query::ObjectWithArgs& _internal_name() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_name();

  public:
  // .pg_query.TypeName storedtype = 6 [json_name = "storedtype"];
  bool has_storedtype() const;
  void clear_storedtype() ;
  const ::pg_query::TypeName& storedtype() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_storedtype();
  ::pg_query::TypeName* mutable_storedtype();
  void set_allocated_storedtype(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_storedtype(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_storedtype();

  private:
  const ::pg_query::TypeName& _internal_storedtype() const;
  ::pg_query::TypeName* _internal_mutable_storedtype();

  public:
  // int32 itemtype = 1 [json_name = "itemtype"];
  void clear_itemtype() ;
  ::int32_t itemtype() const;
  void set_itemtype(::int32_t value);

  private:
  ::int32_t _internal_itemtype() const;
  void _internal_set_itemtype(::int32_t value);

  public:
  // int32 number = 3 [json_name = "number"];
  void clear_number() ;
  ::int32_t number() const;
  void set_number(::int32_t value);

  private:
  ::int32_t _internal_number() const;
  void _internal_set_number(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 4,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > order_family_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > class_args_;
    ::pg_query::ObjectWithArgs* name_;
    ::pg_query::TypeName* storedtype_;
    ::int32_t itemtype_;
    ::int32_t number_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateOpClassStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateOpClassStmt) */ {
 public:
  inline CreateOpClassStmt() : CreateOpClassStmt(nullptr) {}
  ~CreateOpClassStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateOpClassStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateOpClassStmt(const CreateOpClassStmt& from)
      : CreateOpClassStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateOpClassStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateOpClassStmt* internal_default_instance() {
    return reinterpret_cast<const CreateOpClassStmt*>(
               &_CreateOpClassStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    182;

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

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

  CreateOpClassStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateOpClassStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateOpClassStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateOpClassStmt& from) {
    CreateOpClassStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateOpClassStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateOpClassStmt";
  }
  protected:
  explicit CreateOpClassStmt(::google::protobuf::Arena* arena);
  CreateOpClassStmt(::google::protobuf::Arena* arena, const CreateOpClassStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_opclassname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_opclassname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_opclassname();
  public:
  const ::pg_query::Node& opclassname(int index) const;
  ::pg_query::Node* add_opclassname();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_opfamilyname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_opfamilyname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_opfamilyname();
  public:
  const ::pg_query::Node& opfamilyname(int index) const;
  ::pg_query::Node* add_opfamilyname();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_items();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_items() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_items();
  public:
  const ::pg_query::Node& items(int index) const;
  ::pg_query::Node* add_items();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      items() const;
  // string amname = 3 [json_name = "amname"];
  void clear_amname() ;
  const std::string& amname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_amname(Arg_&& arg, Args_... args);
  std::string* mutable_amname();
  PROTOBUF_NODISCARD std::string* release_amname();
  void set_allocated_amname(std::string* value);

  private:
  const std::string& _internal_amname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_datatype() ;
  const ::pg_query::TypeName& datatype() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_datatype();
  ::pg_query::TypeName* mutable_datatype();
  void set_allocated_datatype(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_datatype(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_datatype();

  private:
  const ::pg_query::TypeName& _internal_datatype() const;
  ::pg_query::TypeName* _internal_mutable_datatype();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 4,
      41, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > opclassname_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > opfamilyname_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > items_;
    ::google::protobuf::internal::ArenaStringPtr amname_;
    ::pg_query::TypeName* datatype_;
    bool is_default_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateOpFamilyStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateOpFamilyStmt) */ {
 public:
  inline CreateOpFamilyStmt() : CreateOpFamilyStmt(nullptr) {}
  ~CreateOpFamilyStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateOpFamilyStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateOpFamilyStmt(const CreateOpFamilyStmt& from)
      : CreateOpFamilyStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateOpFamilyStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateOpFamilyStmt* internal_default_instance() {
    return reinterpret_cast<const CreateOpFamilyStmt*>(
               &_CreateOpFamilyStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    184;

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

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

  CreateOpFamilyStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateOpFamilyStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateOpFamilyStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateOpFamilyStmt& from) {
    CreateOpFamilyStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateOpFamilyStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateOpFamilyStmt";
  }
  protected:
  explicit CreateOpFamilyStmt(::google::protobuf::Arena* arena);
  CreateOpFamilyStmt(::google::protobuf::Arena* arena, const CreateOpFamilyStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_opfamilyname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_opfamilyname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_opfamilyname();
  public:
  const ::pg_query::Node& opfamilyname(int index) const;
  ::pg_query::Node* add_opfamilyname();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      opfamilyname() const;
  // string amname = 2 [json_name = "amname"];
  void clear_amname() ;
  const std::string& amname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_amname(Arg_&& arg, Args_... args);
  std::string* mutable_amname();
  PROTOBUF_NODISCARD std::string* release_amname();
  void set_allocated_amname(std::string* value);

  private:
  const std::string& _internal_amname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      42, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > opfamilyname_;
    ::google::protobuf::internal::ArenaStringPtr amname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreatePLangStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreatePLangStmt) */ {
 public:
  inline CreatePLangStmt() : CreatePLangStmt(nullptr) {}
  ~CreatePLangStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreatePLangStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreatePLangStmt(const CreatePLangStmt& from)
      : CreatePLangStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreatePLangStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreatePLangStmt* internal_default_instance() {
    return reinterpret_cast<const CreatePLangStmt*>(
               &_CreatePLangStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    173;

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

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

  CreatePLangStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreatePLangStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreatePLangStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreatePLangStmt& from) {
    CreatePLangStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreatePLangStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreatePLangStmt";
  }
  protected:
  explicit CreatePLangStmt(::google::protobuf::Arena* arena);
  CreatePLangStmt(::google::protobuf::Arena* arena, const CreatePLangStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_plhandler();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_plhandler() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_plhandler();
  public:
  const ::pg_query::Node& plhandler(int index) const;
  ::pg_query::Node* add_plhandler();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_plinline();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_plinline() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_plinline();
  public:
  const ::pg_query::Node& plinline(int index) const;
  ::pg_query::Node* add_plinline();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_plvalidator();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_plvalidator() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_plvalidator();
  public:
  const ::pg_query::Node& plvalidator(int index) const;
  ::pg_query::Node* add_plvalidator();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      plvalidator() const;
  // string plname = 2 [json_name = "plname"];
  void clear_plname() ;
  const std::string& plname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_plname(Arg_&& arg, Args_... args);
  std::string* mutable_plname();
  PROTOBUF_NODISCARD std::string* release_plname();
  void set_allocated_plname(std::string* value);

  private:
  const std::string& _internal_plname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 3,
      39, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > plhandler_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > plinline_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > plvalidator_;
    ::google::protobuf::internal::ArenaStringPtr plname_;
    bool replace_;
    bool pltrusted_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreatePolicyStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreatePolicyStmt) */ {
 public:
  inline CreatePolicyStmt() : CreatePolicyStmt(nullptr) {}
  ~CreatePolicyStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreatePolicyStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreatePolicyStmt(const CreatePolicyStmt& from)
      : CreatePolicyStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreatePolicyStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreatePolicyStmt* internal_default_instance() {
    return reinterpret_cast<const CreatePolicyStmt*>(
               &_CreatePolicyStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    167;

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

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

  CreatePolicyStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreatePolicyStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreatePolicyStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreatePolicyStmt& from) {
    CreatePolicyStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreatePolicyStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreatePolicyStmt";
  }
  protected:
  explicit CreatePolicyStmt(::google::protobuf::Arena* arena);
  CreatePolicyStmt(::google::protobuf::Arena* arena, const CreatePolicyStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_roles();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_roles() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_roles();
  public:
  const ::pg_query::Node& roles(int index) const;
  ::pg_query::Node* add_roles();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      roles() const;
  // string policy_name = 1 [json_name = "policy_name"];
  void clear_policy_name() ;
  const std::string& policy_name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_policy_name(Arg_&& arg, Args_... args);
  std::string* mutable_policy_name();
  PROTOBUF_NODISCARD std::string* release_policy_name();
  void set_allocated_policy_name(std::string* value);

  private:
  const std::string& _internal_policy_name() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_cmd_name(Arg_&& arg, Args_... args);
  std::string* mutable_cmd_name();
  PROTOBUF_NODISCARD std::string* release_cmd_name();
  void set_allocated_cmd_name(std::string* value);

  private:
  const std::string& _internal_cmd_name() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_table() ;
  const ::pg_query::RangeVar& table() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_table();
  ::pg_query::RangeVar* mutable_table();
  void set_allocated_table(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_table(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_table();

  private:
  const ::pg_query::RangeVar& _internal_table() const;
  ::pg_query::RangeVar* _internal_mutable_table();

  public:
  // .pg_query.Node qual = 6 [json_name = "qual"];
  bool has_qual() const;
  void clear_qual() ;
  const ::pg_query::Node& qual() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_qual();
  ::pg_query::Node* mutable_qual();
  void set_allocated_qual(::pg_query::Node* value);
  void unsafe_arena_set_allocated_qual(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_qual();

  private:
  const ::pg_query::Node& _internal_qual() const;
  ::pg_query::Node* _internal_mutable_qual();

  public:
  // .pg_query.Node with_check = 7 [json_name = "with_check"];
  bool has_with_check() const;
  void clear_with_check() ;
  const ::pg_query::Node& with_check() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_with_check();
  ::pg_query::Node* mutable_with_check();
  void set_allocated_with_check(::pg_query::Node* value);
  void unsafe_arena_set_allocated_with_check(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_with_check();

  private:
  const ::pg_query::Node& _internal_with_check() const;
  ::pg_query::Node* _internal_mutable_with_check();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 4,
      53, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > roles_;
    ::google::protobuf::internal::ArenaStringPtr policy_name_;
    ::google::protobuf::internal::ArenaStringPtr cmd_name_;
    ::pg_query::RangeVar* table_;
    ::pg_query::Node* qual_;
    ::pg_query::Node* with_check_;
    bool permissive_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreatePublicationStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreatePublicationStmt) */ {
 public:
  inline CreatePublicationStmt() : CreatePublicationStmt(nullptr) {}
  ~CreatePublicationStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreatePublicationStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreatePublicationStmt(const CreatePublicationStmt& from)
      : CreatePublicationStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreatePublicationStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreatePublicationStmt* internal_default_instance() {
    return reinterpret_cast<const CreatePublicationStmt*>(
               &_CreatePublicationStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    250;

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

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

  CreatePublicationStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreatePublicationStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreatePublicationStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreatePublicationStmt& from) {
    CreatePublicationStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreatePublicationStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreatePublicationStmt";
  }
  protected:
  explicit CreatePublicationStmt(::google::protobuf::Arena* arena);
  CreatePublicationStmt(::google::protobuf::Arena* arena, const CreatePublicationStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kOptionsFieldNumber = 2,
    kPubobjectsFieldNumber = 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // repeated .pg_query.Node pubobjects = 3 [json_name = "pubobjects"];
  int pubobjects_size() const;
  private:
  int _internal_pubobjects_size() const;

  public:
  void clear_pubobjects() ;
  ::pg_query::Node* mutable_pubobjects(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_pubobjects();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_pubobjects() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_pubobjects();
  public:
  const ::pg_query::Node& pubobjects(int index) const;
  ::pg_query::Node* add_pubobjects();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      pubobjects() const;
  // string pubname = 1 [json_name = "pubname"];
  void clear_pubname() ;
  const std::string& pubname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_pubname(Arg_&& arg, Args_... args);
  std::string* mutable_pubname();
  PROTOBUF_NODISCARD std::string* release_pubname();
  void set_allocated_pubname(std::string* value);

  private:
  const std::string& _internal_pubname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      46, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > pubobjects_;
    ::google::protobuf::internal::ArenaStringPtr pubname_;
    bool for_all_tables_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateRangeStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateRangeStmt) */ {
 public:
  inline CreateRangeStmt() : CreateRangeStmt(nullptr) {}
  ~CreateRangeStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateRangeStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateRangeStmt(const CreateRangeStmt& from)
      : CreateRangeStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateRangeStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateRangeStmt* internal_default_instance() {
    return reinterpret_cast<const CreateRangeStmt*>(
               &_CreateRangeStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    217;

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

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

  CreateRangeStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateRangeStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateRangeStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateRangeStmt& from) {
    CreateRangeStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateRangeStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateRangeStmt";
  }
  protected:
  explicit CreateRangeStmt(::google::protobuf::Arena* arena);
  CreateRangeStmt(::google::protobuf::Arena* arena, const CreateRangeStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_type_name();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_type_name() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_type_name();
  public:
  const ::pg_query::Node& type_name(int index) const;
  ::pg_query::Node* add_type_name();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_params();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_params() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_params();
  public:
  const ::pg_query::Node& params(int index) const;
  ::pg_query::Node* add_params();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      params() const;
  // @@protoc_insertion_point(class_scope:pg_query.CreateRangeStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > type_name_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > params_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateRoleStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateRoleStmt) */ {
 public:
  inline CreateRoleStmt() : CreateRoleStmt(nullptr) {}
  ~CreateRoleStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateRoleStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateRoleStmt(const CreateRoleStmt& from)
      : CreateRoleStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateRoleStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateRoleStmt* internal_default_instance() {
    return reinterpret_cast<const CreateRoleStmt*>(
               &_CreateRoleStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    174;

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

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

  CreateRoleStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateRoleStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateRoleStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateRoleStmt& from) {
    CreateRoleStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateRoleStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateRoleStmt";
  }
  protected:
  explicit CreateRoleStmt(::google::protobuf::Arena* arena);
  CreateRoleStmt(::google::protobuf::Arena* arena, const CreateRoleStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string role = 2 [json_name = "role"];
  void clear_role() ;
  const std::string& role() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_role(Arg_&& arg, Args_... args);
  std::string* mutable_role();
  PROTOBUF_NODISCARD std::string* release_role();
  void set_allocated_role(std::string* value);

  private:
  const std::string& _internal_role() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      36, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr role_;
    int stmt_type_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateSchemaStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateSchemaStmt) */ {
 public:
  inline CreateSchemaStmt() : CreateSchemaStmt(nullptr) {}
  ~CreateSchemaStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateSchemaStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateSchemaStmt(const CreateSchemaStmt& from)
      : CreateSchemaStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateSchemaStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateSchemaStmt* internal_default_instance() {
    return reinterpret_cast<const CreateSchemaStmt*>(
               &_CreateSchemaStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    135;

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

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

  CreateSchemaStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateSchemaStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateSchemaStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateSchemaStmt& from) {
    CreateSchemaStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateSchemaStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateSchemaStmt";
  }
  protected:
  explicit CreateSchemaStmt(::google::protobuf::Arena* arena);
  CreateSchemaStmt(::google::protobuf::Arena* arena, const CreateSchemaStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_schema_elts();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_schema_elts() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_schema_elts();
  public:
  const ::pg_query::Node& schema_elts(int index) const;
  ::pg_query::Node* add_schema_elts();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      schema_elts() const;
  // string schemaname = 1 [json_name = "schemaname"];
  void clear_schemaname() ;
  const std::string& schemaname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_schemaname(Arg_&& arg, Args_... args);
  std::string* mutable_schemaname();
  PROTOBUF_NODISCARD std::string* release_schemaname();
  void set_allocated_schemaname(std::string* value);

  private:
  const std::string& _internal_schemaname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_authrole() ;
  const ::pg_query::RoleSpec& authrole() const;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_authrole();
  ::pg_query::RoleSpec* mutable_authrole();
  void set_allocated_authrole(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_authrole(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_authrole();

  private:
  const ::pg_query::RoleSpec& _internal_authrole() const;
  ::pg_query::RoleSpec* _internal_mutable_authrole();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      44, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > schema_elts_;
    ::google::protobuf::internal::ArenaStringPtr schemaname_;
    ::pg_query::RoleSpec* authrole_;
    bool if_not_exists_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateSeqStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateSeqStmt) */ {
 public:
  inline CreateSeqStmt() : CreateSeqStmt(nullptr) {}
  ~CreateSeqStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateSeqStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateSeqStmt(const CreateSeqStmt& from)
      : CreateSeqStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateSeqStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateSeqStmt* internal_default_instance() {
    return reinterpret_cast<const CreateSeqStmt*>(
               &_CreateSeqStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    178;

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

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

  CreateSeqStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateSeqStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateSeqStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateSeqStmt& from) {
    CreateSeqStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateSeqStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateSeqStmt";
  }
  protected:
  explicit CreateSeqStmt(::google::protobuf::Arena* arena);
  CreateSeqStmt(::google::protobuf::Arena* arena, const CreateSeqStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // .pg_query.RangeVar sequence = 1 [json_name = "sequence"];
  bool has_sequence() const;
  void clear_sequence() ;
  const ::pg_query::RangeVar& sequence() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_sequence();
  ::pg_query::RangeVar* mutable_sequence();
  void set_allocated_sequence(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_sequence(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_sequence();

  private:
  const ::pg_query::RangeVar& _internal_sequence() const;
  ::pg_query::RangeVar* _internal_mutable_sequence();

  public:
  // uint32 owner_id = 3 [json_name = "ownerId"];
  void clear_owner_id() ;
  ::uint32_t owner_id() const;
  void set_owner_id(::uint32_t value);

  private:
  ::uint32_t _internal_owner_id() const;
  void _internal_set_owner_id(::uint32_t 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::pg_query::RangeVar* sequence_;
    ::uint32_t owner_id_;
    bool for_identity_;
    bool if_not_exists_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateStatsStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateStatsStmt) */ {
 public:
  inline CreateStatsStmt() : CreateStatsStmt(nullptr) {}
  ~CreateStatsStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateStatsStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateStatsStmt(const CreateStatsStmt& from)
      : CreateStatsStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateStatsStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateStatsStmt* internal_default_instance() {
    return reinterpret_cast<const CreateStatsStmt*>(
               &_CreateStatsStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    194;

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

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

  CreateStatsStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateStatsStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateStatsStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateStatsStmt& from) {
    CreateStatsStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateStatsStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateStatsStmt";
  }
  protected:
  explicit CreateStatsStmt(::google::protobuf::Arena* arena);
  CreateStatsStmt(::google::protobuf::Arena* arena, const CreateStatsStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDefnamesFieldNumber = 1,
    kStatTypesFieldNumber = 2,
    kExprsFieldNumber = 3,
    kRelationsFieldNumber = 4,
    kStxcommentFieldNumber = 5,
    kTransformedFieldNumber = 6,
    kIfNotExistsFieldNumber = 7,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_defnames();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_defnames() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_defnames();
  public:
  const ::pg_query::Node& defnames(int index) const;
  ::pg_query::Node* add_defnames();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_stat_types();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_stat_types() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_stat_types();
  public:
  const ::pg_query::Node& stat_types(int index) const;
  ::pg_query::Node* add_stat_types();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_exprs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_exprs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_exprs();
  public:
  const ::pg_query::Node& exprs(int index) const;
  ::pg_query::Node* add_exprs();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_relations();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_relations() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_relations();
  public:
  const ::pg_query::Node& relations(int index) const;
  ::pg_query::Node* add_relations();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      relations() const;
  // string stxcomment = 5 [json_name = "stxcomment"];
  void clear_stxcomment() ;
  const std::string& stxcomment() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_stxcomment(Arg_&& arg, Args_... args);
  std::string* mutable_stxcomment();
  PROTOBUF_NODISCARD std::string* release_stxcomment();
  void set_allocated_stxcomment(std::string* value);

  private:
  const std::string& _internal_stxcomment() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stxcomment(
      const std::string& value);
  std::string* _internal_mutable_stxcomment();

  public:
  // bool transformed = 6 [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 if_not_exists = 7 [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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 4,
      43, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > defnames_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > stat_types_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > exprs_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > relations_;
    ::google::protobuf::internal::ArenaStringPtr stxcomment_;
    bool transformed_;
    bool if_not_exists_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateStmt) */ {
 public:
  inline CreateStmt() : CreateStmt(nullptr) {}
  ~CreateStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateStmt(const CreateStmt& from)
      : CreateStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateStmt* internal_default_instance() {
    return reinterpret_cast<const CreateStmt*>(
               &_CreateStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    149;

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

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

  CreateStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateStmt& from) {
    CreateStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateStmt";
  }
  protected:
  explicit CreateStmt(::google::protobuf::Arena* arena);
  CreateStmt(::google::protobuf::Arena* arena, const CreateStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_table_elts();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_table_elts() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_table_elts();
  public:
  const ::pg_query::Node& table_elts(int index) const;
  ::pg_query::Node* add_table_elts();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_inh_relations();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_inh_relations() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_inh_relations();
  public:
  const ::pg_query::Node& inh_relations(int index) const;
  ::pg_query::Node* add_inh_relations();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_constraints();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_constraints() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_constraints();
  public:
  const ::pg_query::Node& constraints(int index) const;
  ::pg_query::Node* add_constraints();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string tablespacename = 10 [json_name = "tablespacename"];
  void clear_tablespacename() ;
  const std::string& tablespacename() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_tablespacename(Arg_&& arg, Args_... args);
  std::string* mutable_tablespacename();
  PROTOBUF_NODISCARD std::string* release_tablespacename();
  void set_allocated_tablespacename(std::string* value);

  private:
  const std::string& _internal_tablespacename() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_access_method(Arg_&& arg, Args_... args);
  std::string* mutable_access_method();
  PROTOBUF_NODISCARD std::string* release_access_method();
  void set_allocated_access_method(std::string* value);

  private:
  const std::string& _internal_access_method() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.PartitionBoundSpec partbound = 4 [json_name = "partbound"];
  bool has_partbound() const;
  void clear_partbound() ;
  const ::pg_query::PartitionBoundSpec& partbound() const;
  PROTOBUF_NODISCARD ::pg_query::PartitionBoundSpec* release_partbound();
  ::pg_query::PartitionBoundSpec* mutable_partbound();
  void set_allocated_partbound(::pg_query::PartitionBoundSpec* value);
  void unsafe_arena_set_allocated_partbound(::pg_query::PartitionBoundSpec* value);
  ::pg_query::PartitionBoundSpec* unsafe_arena_release_partbound();

  private:
  const ::pg_query::PartitionBoundSpec& _internal_partbound() const;
  ::pg_query::PartitionBoundSpec* _internal_mutable_partbound();

  public:
  // .pg_query.PartitionSpec partspec = 5 [json_name = "partspec"];
  bool has_partspec() const;
  void clear_partspec() ;
  const ::pg_query::PartitionSpec& partspec() const;
  PROTOBUF_NODISCARD ::pg_query::PartitionSpec* release_partspec();
  ::pg_query::PartitionSpec* mutable_partspec();
  void set_allocated_partspec(::pg_query::PartitionSpec* value);
  void unsafe_arena_set_allocated_partspec(::pg_query::PartitionSpec* value);
  ::pg_query::PartitionSpec* unsafe_arena_release_partspec();

  private:
  const ::pg_query::PartitionSpec& _internal_partspec() const;
  ::pg_query::PartitionSpec* _internal_mutable_partspec();

  public:
  // .pg_query.TypeName of_typename = 6 [json_name = "ofTypename"];
  bool has_of_typename() const;
  void clear_of_typename() ;
  const ::pg_query::TypeName& of_typename() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_of_typename();
  ::pg_query::TypeName* mutable_of_typename();
  void set_allocated_of_typename(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_of_typename(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_of_typename();

  private:
  const ::pg_query::TypeName& _internal_of_typename() const;
  ::pg_query::TypeName* _internal_mutable_of_typename();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 12, 8,
      63, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > table_elts_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > inh_relations_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > constraints_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr tablespacename_;
    ::google::protobuf::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_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateSubscriptionStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateSubscriptionStmt) */ {
 public:
  inline CreateSubscriptionStmt() : CreateSubscriptionStmt(nullptr) {}
  ~CreateSubscriptionStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateSubscriptionStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateSubscriptionStmt(const CreateSubscriptionStmt& from)
      : CreateSubscriptionStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateSubscriptionStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateSubscriptionStmt* internal_default_instance() {
    return reinterpret_cast<const CreateSubscriptionStmt*>(
               &_CreateSubscriptionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    252;

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

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

  CreateSubscriptionStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateSubscriptionStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateSubscriptionStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateSubscriptionStmt& from) {
    CreateSubscriptionStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateSubscriptionStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateSubscriptionStmt";
  }
  protected:
  explicit CreateSubscriptionStmt(::google::protobuf::Arena* arena);
  CreateSubscriptionStmt(::google::protobuf::Arena* arena, const CreateSubscriptionStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_publication();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_publication() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_publication();
  public:
  const ::pg_query::Node& publication(int index) const;
  ::pg_query::Node* add_publication();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string subname = 1 [json_name = "subname"];
  void clear_subname() ;
  const std::string& subname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_subname(Arg_&& arg, Args_... args);
  std::string* mutable_subname();
  PROTOBUF_NODISCARD std::string* release_subname();
  void set_allocated_subname(std::string* value);

  private:
  const std::string& _internal_subname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_conninfo(Arg_&& arg, Args_... args);
  std::string* mutable_conninfo();
  PROTOBUF_NODISCARD std::string* release_conninfo();
  void set_allocated_conninfo(std::string* value);

  private:
  const std::string& _internal_conninfo() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      55, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > publication_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr subname_;
    ::google::protobuf::internal::ArenaStringPtr conninfo_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateTableAsStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateTableAsStmt) */ {
 public:
  inline CreateTableAsStmt() : CreateTableAsStmt(nullptr) {}
  ~CreateTableAsStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateTableAsStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateTableAsStmt(const CreateTableAsStmt& from)
      : CreateTableAsStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateTableAsStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateTableAsStmt* internal_default_instance() {
    return reinterpret_cast<const CreateTableAsStmt*>(
               &_CreateTableAsStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    231;

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

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

  CreateTableAsStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateTableAsStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateTableAsStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateTableAsStmt& from) {
    CreateTableAsStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateTableAsStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateTableAsStmt";
  }
  protected:
  explicit CreateTableAsStmt(::google::protobuf::Arena* arena);
  CreateTableAsStmt(::google::protobuf::Arena* arena, const CreateTableAsStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kQueryFieldNumber = 1,
    kIntoFieldNumber = 2,
    kObjtypeFieldNumber = 3,
    kIsSelectIntoFieldNumber = 4,
    kIfNotExistsFieldNumber = 5,
  };
  // .pg_query.Node query = 1 [json_name = "query"];
  bool has_query() const;
  void clear_query() ;
  const ::pg_query::Node& query() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* value);
  void unsafe_arena_set_allocated_query(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_query();

  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();

  public:
  // .pg_query.IntoClause into = 2 [json_name = "into"];
  bool has_into() const;
  void clear_into() ;
  const ::pg_query::IntoClause& into() const;
  PROTOBUF_NODISCARD ::pg_query::IntoClause* release_into();
  ::pg_query::IntoClause* mutable_into();
  void set_allocated_into(::pg_query::IntoClause* value);
  void unsafe_arena_set_allocated_into(::pg_query::IntoClause* value);
  ::pg_query::IntoClause* unsafe_arena_release_into();

  private:
  const ::pg_query::IntoClause& _internal_into() const;
  ::pg_query::IntoClause* _internal_mutable_into();

  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_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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* query_;
    ::pg_query::IntoClause* into_;
    int objtype_;
    bool is_select_into_;
    bool if_not_exists_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateTableSpaceStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateTableSpaceStmt) */ {
 public:
  inline CreateTableSpaceStmt() : CreateTableSpaceStmt(nullptr) {}
  ~CreateTableSpaceStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateTableSpaceStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateTableSpaceStmt(const CreateTableSpaceStmt& from)
      : CreateTableSpaceStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateTableSpaceStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateTableSpaceStmt* internal_default_instance() {
    return reinterpret_cast<const CreateTableSpaceStmt*>(
               &_CreateTableSpaceStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    151;

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

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

  CreateTableSpaceStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateTableSpaceStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateTableSpaceStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateTableSpaceStmt& from) {
    CreateTableSpaceStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateTableSpaceStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateTableSpaceStmt";
  }
  protected:
  explicit CreateTableSpaceStmt(::google::protobuf::Arena* arena);
  CreateTableSpaceStmt(::google::protobuf::Arena* arena, const CreateTableSpaceStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string tablespacename = 1 [json_name = "tablespacename"];
  void clear_tablespacename() ;
  const std::string& tablespacename() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_tablespacename(Arg_&& arg, Args_... args);
  std::string* mutable_tablespacename();
  PROTOBUF_NODISCARD std::string* release_tablespacename();
  void set_allocated_tablespacename(std::string* value);

  private:
  const std::string& _internal_tablespacename() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_location(Arg_&& arg, Args_... args);
  std::string* mutable_location();
  PROTOBUF_NODISCARD std::string* release_location();
  void set_allocated_location(std::string* value);

  private:
  const std::string& _internal_location() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_owner() ;
  const ::pg_query::RoleSpec& owner() const;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_owner();
  ::pg_query::RoleSpec* mutable_owner();
  void set_allocated_owner(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_owner(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_owner();

  private:
  const ::pg_query::RoleSpec& _internal_owner() const;
  ::pg_query::RoleSpec* _internal_mutable_owner();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      60, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr tablespacename_;
    ::google::protobuf::internal::ArenaStringPtr location_;
    ::pg_query::RoleSpec* owner_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateTransformStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateTransformStmt) */ {
 public:
  inline CreateTransformStmt() : CreateTransformStmt(nullptr) {}
  ~CreateTransformStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateTransformStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateTransformStmt(const CreateTransformStmt& from)
      : CreateTransformStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateTransformStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateTransformStmt* internal_default_instance() {
    return reinterpret_cast<const CreateTransformStmt*>(
               &_CreateTransformStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    240;

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

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

  CreateTransformStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateTransformStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateTransformStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateTransformStmt& from) {
    CreateTransformStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateTransformStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateTransformStmt";
  }
  protected:
  explicit CreateTransformStmt(::google::protobuf::Arena* arena);
  CreateTransformStmt(::google::protobuf::Arena* arena, const CreateTransformStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_lang(Arg_&& arg, Args_... args);
  std::string* mutable_lang();
  PROTOBUF_NODISCARD std::string* release_lang();
  void set_allocated_lang(std::string* value);

  private:
  const std::string& _internal_lang() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_type_name() ;
  const ::pg_query::TypeName& type_name() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_type_name(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();

  public:
  // .pg_query.ObjectWithArgs fromsql = 4 [json_name = "fromsql"];
  bool has_fromsql() const;
  void clear_fromsql() ;
  const ::pg_query::ObjectWithArgs& fromsql() const;
  PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_fromsql();
  ::pg_query::ObjectWithArgs* mutable_fromsql();
  void set_allocated_fromsql(::pg_query::ObjectWithArgs* value);
  void unsafe_arena_set_allocated_fromsql(::pg_query::ObjectWithArgs* value);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_fromsql();

  private:
  const ::pg_query::ObjectWithArgs& _internal_fromsql() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_fromsql();

  public:
  // .pg_query.ObjectWithArgs tosql = 5 [json_name = "tosql"];
  bool has_tosql() const;
  void clear_tosql() ;
  const ::pg_query::ObjectWithArgs& tosql() const;
  PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_tosql();
  ::pg_query::ObjectWithArgs* mutable_tosql();
  void set_allocated_tosql(::pg_query::ObjectWithArgs* value);
  void unsafe_arena_set_allocated_tosql(::pg_query::ObjectWithArgs* value);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_tosql();

  private:
  const ::pg_query::ObjectWithArgs& _internal_tosql() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_tosql();

  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:
  // @@protoc_insertion_point(class_scope:pg_query.CreateTransformStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 3,
      41, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr lang_;
    ::pg_query::TypeName* type_name_;
    ::pg_query::ObjectWithArgs* fromsql_;
    ::pg_query::ObjectWithArgs* tosql_;
    bool replace_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateTrigStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateTrigStmt) */ {
 public:
  inline CreateTrigStmt() : CreateTrigStmt(nullptr) {}
  ~CreateTrigStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateTrigStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateTrigStmt(const CreateTrigStmt& from)
      : CreateTrigStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateTrigStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateTrigStmt* internal_default_instance() {
    return reinterpret_cast<const CreateTrigStmt*>(
               &_CreateTrigStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    170;

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

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

  CreateTrigStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateTrigStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateTrigStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateTrigStmt& from) {
    CreateTrigStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateTrigStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateTrigStmt";
  }
  protected:
  explicit CreateTrigStmt(::google::protobuf::Arena* arena);
  CreateTrigStmt(::google::protobuf::Arena* arena, const CreateTrigStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kFuncnameFieldNumber = 5,
    kArgsFieldNumber = 6,
    kColumnsFieldNumber = 10,
    kTransitionRelsFieldNumber = 12,
    kTrignameFieldNumber = 3,
    kRelationFieldNumber = 4,
    kWhenClauseFieldNumber = 11,
    kConstrrelFieldNumber = 15,
    kReplaceFieldNumber = 1,
    kIsconstraintFieldNumber = 2,
    kRowFieldNumber = 7,
    kDeferrableFieldNumber = 13,
    kTimingFieldNumber = 8,
    kEventsFieldNumber = 9,
    kInitdeferredFieldNumber = 14,
  };
  // repeated .pg_query.Node funcname = 5 [json_name = "funcname"];
  int funcname_size() const;
  private:
  int _internal_funcname_size() const;

  public:
  void clear_funcname() ;
  ::pg_query::Node* mutable_funcname(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_funcname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_funcname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_funcname();
  public:
  const ::pg_query::Node& funcname(int index) const;
  ::pg_query::Node* add_funcname();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      funcname() 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // repeated .pg_query.Node columns = 10 [json_name = "columns"];
  int columns_size() const;
  private:
  int _internal_columns_size() const;

  public:
  void clear_columns() ;
  ::pg_query::Node* mutable_columns(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_columns();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_columns() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_columns();
  public:
  const ::pg_query::Node& columns(int index) const;
  ::pg_query::Node* add_columns();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      columns() const;
  // repeated .pg_query.Node transition_rels = 12 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_transition_rels();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_transition_rels() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_transition_rels();
  public:
  const ::pg_query::Node& transition_rels(int index) const;
  ::pg_query::Node* add_transition_rels();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      transition_rels() const;
  // string trigname = 3 [json_name = "trigname"];
  void clear_trigname() ;
  const std::string& trigname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_trigname(Arg_&& arg, Args_... args);
  std::string* mutable_trigname();
  PROTOBUF_NODISCARD std::string* release_trigname();
  void set_allocated_trigname(std::string* value);

  private:
  const std::string& _internal_trigname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_trigname(
      const std::string& value);
  std::string* _internal_mutable_trigname();

  public:
  // .pg_query.RangeVar relation = 4 [json_name = "relation"];
  bool has_relation() const;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node when_clause = 11 [json_name = "whenClause"];
  bool has_when_clause() const;
  void clear_when_clause() ;
  const ::pg_query::Node& when_clause() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_when_clause();
  ::pg_query::Node* mutable_when_clause();
  void set_allocated_when_clause(::pg_query::Node* value);
  void unsafe_arena_set_allocated_when_clause(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_when_clause();

  private:
  const ::pg_query::Node& _internal_when_clause() const;
  ::pg_query::Node* _internal_mutable_when_clause();

  public:
  // .pg_query.RangeVar constrrel = 15 [json_name = "constrrel"];
  bool has_constrrel() const;
  void clear_constrrel() ;
  const ::pg_query::RangeVar& constrrel() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_constrrel();
  ::pg_query::RangeVar* mutable_constrrel();
  void set_allocated_constrrel(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_constrrel(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_constrrel();

  private:
  const ::pg_query::RangeVar& _internal_constrrel() const;
  ::pg_query::RangeVar* _internal_mutable_constrrel();

  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 isconstraint = 2 [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 row = 7 [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 deferrable = 13 [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:
  // int32 timing = 8 [json_name = "timing"];
  void clear_timing() ;
  ::int32_t timing() const;
  void set_timing(::int32_t value);

  private:
  ::int32_t _internal_timing() const;
  void _internal_set_timing(::int32_t value);

  public:
  // int32 events = 9 [json_name = "events"];
  void clear_events() ;
  ::int32_t events() const;
  void set_events(::int32_t value);

  private:
  ::int32_t _internal_events() const;
  void _internal_set_events(::int32_t value);

  public:
  // bool initdeferred = 14 [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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 15, 7,
      48, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > funcname_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > columns_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > transition_rels_;
    ::google::protobuf::internal::ArenaStringPtr trigname_;
    ::pg_query::RangeVar* relation_;
    ::pg_query::Node* when_clause_;
    ::pg_query::RangeVar* constrrel_;
    bool replace_;
    bool isconstraint_;
    bool row_;
    bool deferrable_;
    ::int32_t timing_;
    ::int32_t events_;
    bool initdeferred_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreateUserMappingStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateUserMappingStmt) */ {
 public:
  inline CreateUserMappingStmt() : CreateUserMappingStmt(nullptr) {}
  ~CreateUserMappingStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreateUserMappingStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreateUserMappingStmt(const CreateUserMappingStmt& from)
      : CreateUserMappingStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateUserMappingStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateUserMappingStmt* internal_default_instance() {
    return reinterpret_cast<const CreateUserMappingStmt*>(
               &_CreateUserMappingStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    163;

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

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

  CreateUserMappingStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreateUserMappingStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreateUserMappingStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreateUserMappingStmt& from) {
    CreateUserMappingStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreateUserMappingStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreateUserMappingStmt";
  }
  protected:
  explicit CreateUserMappingStmt(::google::protobuf::Arena* arena);
  CreateUserMappingStmt(::google::protobuf::Arena* arena, const CreateUserMappingStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string servername = 2 [json_name = "servername"];
  void clear_servername() ;
  const std::string& servername() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_servername(Arg_&& arg, Args_... args);
  std::string* mutable_servername();
  PROTOBUF_NODISCARD std::string* release_servername();
  void set_allocated_servername(std::string* value);

  private:
  const std::string& _internal_servername() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_user() ;
  const ::pg_query::RoleSpec& user() const;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_user();
  ::pg_query::RoleSpec* mutable_user();
  void set_allocated_user(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_user(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_user();

  private:
  const ::pg_query::RoleSpec& _internal_user() const;
  ::pg_query::RoleSpec* _internal_mutable_user();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      49, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr servername_;
    ::pg_query::RoleSpec* user_;
    bool if_not_exists_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CreatedbStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CreatedbStmt) */ {
 public:
  inline CreatedbStmt() : CreatedbStmt(nullptr) {}
  ~CreatedbStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CreatedbStmt(::google::protobuf::internal::ConstantInitialized);

  inline CreatedbStmt(const CreatedbStmt& from)
      : CreatedbStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreatedbStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreatedbStmt* internal_default_instance() {
    return reinterpret_cast<const CreatedbStmt*>(
               &_CreatedbStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    221;

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

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

  CreatedbStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CreatedbStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CreatedbStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CreatedbStmt& from) {
    CreatedbStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CreatedbStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CreatedbStmt";
  }
  protected:
  explicit CreatedbStmt(::google::protobuf::Arena* arena);
  CreatedbStmt(::google::protobuf::Arena* arena, const CreatedbStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string dbname = 1 [json_name = "dbname"];
  void clear_dbname() ;
  const std::string& dbname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_dbname(Arg_&& arg, Args_... args);
  std::string* mutable_dbname();
  PROTOBUF_NODISCARD std::string* release_dbname();
  void set_allocated_dbname(std::string* value);

  private:
  const std::string& _internal_dbname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      36, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr dbname_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class CurrentOfExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.CurrentOfExpr) */ {
 public:
  inline CurrentOfExpr() : CurrentOfExpr(nullptr) {}
  ~CurrentOfExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CurrentOfExpr(::google::protobuf::internal::ConstantInitialized);

  inline CurrentOfExpr(const CurrentOfExpr& from)
      : CurrentOfExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CurrentOfExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const CurrentOfExpr* internal_default_instance() {
    return reinterpret_cast<const CurrentOfExpr*>(
               &_CurrentOfExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    59;

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

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

  CurrentOfExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CurrentOfExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const CurrentOfExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const CurrentOfExpr& from) {
    CurrentOfExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(CurrentOfExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.CurrentOfExpr";
  }
  protected:
  explicit CurrentOfExpr(::google::protobuf::Arena* arena);
  CurrentOfExpr(::google::protobuf::Arena* arena, const CurrentOfExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_cursor_name(Arg_&& arg, Args_... args);
  std::string* mutable_cursor_name();
  PROTOBUF_NODISCARD std::string* release_cursor_name();
  void set_allocated_cursor_name(std::string* value);

  private:
  const std::string& _internal_cursor_name() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 cvarno = 2 [json_name = "cvarno"];
  void clear_cvarno() ;
  ::uint32_t cvarno() const;
  void set_cvarno(::uint32_t value);

  private:
  ::uint32_t _internal_cvarno() const;
  void _internal_set_cvarno(::uint32_t value);

  public:
  // int32 cursor_param = 4 [json_name = "cursor_param"];
  void clear_cursor_param() ;
  ::int32_t cursor_param() const;
  void set_cursor_param(::int32_t value);

  private:
  ::int32_t _internal_cursor_param() const;
  void _internal_set_cursor_param(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 1,
      42, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr cursor_name_;
    ::pg_query::Node* xpr_;
    ::uint32_t cvarno_;
    ::int32_t cursor_param_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DeclareCursorStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DeclareCursorStmt) */ {
 public:
  inline DeclareCursorStmt() : DeclareCursorStmt(nullptr) {}
  ~DeclareCursorStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DeclareCursorStmt(::google::protobuf::internal::ConstantInitialized);

  inline DeclareCursorStmt(const DeclareCursorStmt& from)
      : DeclareCursorStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DeclareCursorStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DeclareCursorStmt* internal_default_instance() {
    return reinterpret_cast<const DeclareCursorStmt*>(
               &_DeclareCursorStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    190;

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

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

  DeclareCursorStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeclareCursorStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DeclareCursorStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DeclareCursorStmt& from) {
    DeclareCursorStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DeclareCursorStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DeclareCursorStmt";
  }
  protected:
  explicit DeclareCursorStmt(::google::protobuf::Arena* arena);
  DeclareCursorStmt(::google::protobuf::Arena* arena, const DeclareCursorStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_portalname(Arg_&& arg, Args_... args);
  std::string* mutable_portalname();
  PROTOBUF_NODISCARD std::string* release_portalname();
  void set_allocated_portalname(std::string* value);

  private:
  const std::string& _internal_portalname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_query() ;
  const ::pg_query::Node& query() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* value);
  void unsafe_arena_set_allocated_query(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_query();

  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();

  public:
  // int32 options = 2 [json_name = "options"];
  void clear_options() ;
  ::int32_t options() const;
  void set_options(::int32_t value);

  private:
  ::int32_t _internal_options() const;
  void _internal_set_options(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      45, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr portalname_;
    ::pg_query::Node* query_;
    ::int32_t options_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DefElem final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DefElem) */ {
 public:
  inline DefElem() : DefElem(nullptr) {}
  ~DefElem() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DefElem(::google::protobuf::internal::ConstantInitialized);

  inline DefElem(const DefElem& from)
      : DefElem(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DefElem& default_instance() {
    return *internal_default_instance();
  }
  static inline const DefElem* internal_default_instance() {
    return reinterpret_cast<const DefElem*>(
               &_DefElem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    92;

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

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

  DefElem* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DefElem>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DefElem& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DefElem& from) {
    DefElem::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DefElem* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DefElem";
  }
  protected:
  explicit DefElem(::google::protobuf::Arena* arena);
  DefElem(::google::protobuf::Arena* arena, const DefElem& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_defnamespace(Arg_&& arg, Args_... args);
  std::string* mutable_defnamespace();
  PROTOBUF_NODISCARD std::string* release_defnamespace();
  void set_allocated_defnamespace(std::string* value);

  private:
  const std::string& _internal_defnamespace() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_defname(Arg_&& arg, Args_... args);
  std::string* mutable_defname();
  PROTOBUF_NODISCARD std::string* release_defname();
  void set_allocated_defname(std::string* value);

  private:
  const std::string& _internal_defname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_arg() ;
  const ::pg_query::Node& arg() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* value);
  void unsafe_arena_set_allocated_arg(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_arg();

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // .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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 1,
      44, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr defnamespace_;
    ::google::protobuf::internal::ArenaStringPtr defname_;
    ::pg_query::Node* arg_;
    int defaction_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DefineStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DefineStmt) */ {
 public:
  inline DefineStmt() : DefineStmt(nullptr) {}
  ~DefineStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DefineStmt(::google::protobuf::internal::ConstantInitialized);

  inline DefineStmt(const DefineStmt& from)
      : DefineStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DefineStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DefineStmt* internal_default_instance() {
    return reinterpret_cast<const DefineStmt*>(
               &_DefineStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    180;

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

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

  DefineStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DefineStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DefineStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DefineStmt& from) {
    DefineStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DefineStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DefineStmt";
  }
  protected:
  explicit DefineStmt(::google::protobuf::Arena* arena);
  DefineStmt(::google::protobuf::Arena* arena, const DefineStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_defnames();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_defnames() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_defnames();
  public:
  const ::pg_query::Node& defnames(int index) const;
  ::pg_query::Node* add_defnames();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_definition();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_definition() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_definition();
  public:
  const ::pg_query::Node& definition(int index) const;
  ::pg_query::Node* add_definition();
  const ::google::protobuf::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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > defnames_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > definition_;
    int kind_;
    bool oldstyle_;
    bool if_not_exists_;
    bool replace_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DeleteStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DeleteStmt) */ {
 public:
  inline DeleteStmt() : DeleteStmt(nullptr) {}
  ~DeleteStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DeleteStmt(::google::protobuf::internal::ConstantInitialized);

  inline DeleteStmt(const DeleteStmt& from)
      : DeleteStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DeleteStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DeleteStmt* internal_default_instance() {
    return reinterpret_cast<const DeleteStmt*>(
               &_DeleteStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    128;

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

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

  DeleteStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeleteStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DeleteStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DeleteStmt& from) {
    DeleteStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DeleteStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DeleteStmt";
  }
  protected:
  explicit DeleteStmt(::google::protobuf::Arena* arena);
  DeleteStmt(::google::protobuf::Arena* arena, const DeleteStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_using_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_using_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_using_clause();
  public:
  const ::pg_query::Node& using_clause(int index) const;
  ::pg_query::Node* add_using_clause();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_returning_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_returning_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_returning_list();
  public:
  const ::pg_query::Node& returning_list(int index) const;
  ::pg_query::Node* add_returning_list();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      returning_list() const;
  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node where_clause = 3 [json_name = "whereClause"];
  bool has_where_clause() const;
  void clear_where_clause() ;
  const ::pg_query::Node& where_clause() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* value);
  void unsafe_arena_set_allocated_where_clause(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();

  public:
  // .pg_query.WithClause with_clause = 5 [json_name = "withClause"];
  bool has_with_clause() const;
  void clear_with_clause() ;
  const ::pg_query::WithClause& with_clause() const;
  PROTOBUF_NODISCARD ::pg_query::WithClause* release_with_clause();
  ::pg_query::WithClause* mutable_with_clause();
  void set_allocated_with_clause(::pg_query::WithClause* value);
  void unsafe_arena_set_allocated_with_clause(::pg_query::WithClause* value);
  ::pg_query::WithClause* unsafe_arena_release_with_clause();

  private:
  const ::pg_query::WithClause& _internal_with_clause() const;
  ::pg_query::WithClause* _internal_mutable_with_clause();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 5,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > using_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > returning_list_;
    ::pg_query::RangeVar* relation_;
    ::pg_query::Node* where_clause_;
    ::pg_query::WithClause* with_clause_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DistinctExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DistinctExpr) */ {
 public:
  inline DistinctExpr() : DistinctExpr(nullptr) {}
  ~DistinctExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DistinctExpr(::google::protobuf::internal::ConstantInitialized);

  inline DistinctExpr(const DistinctExpr& from)
      : DistinctExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DistinctExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DistinctExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  DistinctExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DistinctExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DistinctExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DistinctExpr& from) {
    DistinctExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DistinctExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DistinctExpr";
  }
  protected:
  explicit DistinctExpr(::google::protobuf::Arena* arena);
  DistinctExpr(::google::protobuf::Arena* arena, const DistinctExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kArgsFieldNumber = 7,
    kXprFieldNumber = 1,
    kOpnoFieldNumber = 2,
    kOpresulttypeFieldNumber = 3,
    kOpretsetFieldNumber = 4,
    kOpcollidFieldNumber = 5,
    kInputcollidFieldNumber = 6,
    kLocationFieldNumber = 8,
  };
  // repeated .pg_query.Node args = 7 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;

  public:
  void clear_args() ;
  ::pg_query::Node* mutable_args(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 opno = 2 [json_name = "opno"];
  void clear_opno() ;
  ::uint32_t opno() const;
  void set_opno(::uint32_t value);

  private:
  ::uint32_t _internal_opno() const;
  void _internal_set_opno(::uint32_t value);

  public:
  // uint32 opresulttype = 3 [json_name = "opresulttype"];
  void clear_opresulttype() ;
  ::uint32_t opresulttype() const;
  void set_opresulttype(::uint32_t value);

  private:
  ::uint32_t _internal_opresulttype() const;
  void _internal_set_opresulttype(::uint32_t value);

  public:
  // bool opretset = 4 [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 = 5 [json_name = "opcollid"];
  void clear_opcollid() ;
  ::uint32_t opcollid() const;
  void set_opcollid(::uint32_t value);

  private:
  ::uint32_t _internal_opcollid() const;
  void _internal_set_opcollid(::uint32_t value);

  public:
  // uint32 inputcollid = 6 [json_name = "inputcollid"];
  void clear_inputcollid() ;
  ::uint32_t inputcollid() const;
  void set_inputcollid(::uint32_t value);

  private:
  ::uint32_t _internal_inputcollid() const;
  void _internal_set_inputcollid(::uint32_t value);

  public:
  // int32 location = 8 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* xpr_;
    ::uint32_t opno_;
    ::uint32_t opresulttype_;
    bool opretset_;
    ::uint32_t opcollid_;
    ::uint32_t inputcollid_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DoStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DoStmt) */ {
 public:
  inline DoStmt() : DoStmt(nullptr) {}
  ~DoStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DoStmt(::google::protobuf::internal::ConstantInitialized);

  inline DoStmt(const DoStmt& from)
      : DoStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DoStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DoStmt* internal_default_instance() {
    return reinterpret_cast<const DoStmt*>(
               &_DoStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    200;

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

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

  DoStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DoStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DoStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DoStmt& from) {
    DoStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DoStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DoStmt";
  }
  protected:
  explicit DoStmt(::google::protobuf::Arena* arena);
  DoStmt(::google::protobuf::Arena* arena, const DoStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // @@protoc_insertion_point(class_scope:pg_query.DoStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DropOwnedStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DropOwnedStmt) */ {
 public:
  inline DropOwnedStmt() : DropOwnedStmt(nullptr) {}
  ~DropOwnedStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DropOwnedStmt(::google::protobuf::internal::ConstantInitialized);

  inline DropOwnedStmt(const DropOwnedStmt& from)
      : DropOwnedStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DropOwnedStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DropOwnedStmt* internal_default_instance() {
    return reinterpret_cast<const DropOwnedStmt*>(
               &_DropOwnedStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    244;

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

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

  DropOwnedStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DropOwnedStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DropOwnedStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DropOwnedStmt& from) {
    DropOwnedStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DropOwnedStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DropOwnedStmt";
  }
  protected:
  explicit DropOwnedStmt(::google::protobuf::Arena* arena);
  DropOwnedStmt(::google::protobuf::Arena* arena, const DropOwnedStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_roles();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_roles() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_roles();
  public:
  const ::pg_query::Node& roles(int index) const;
  ::pg_query::Node* add_roles();
  const ::google::protobuf::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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > roles_;
    int behavior_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DropRoleStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DropRoleStmt) */ {
 public:
  inline DropRoleStmt() : DropRoleStmt(nullptr) {}
  ~DropRoleStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DropRoleStmt(::google::protobuf::internal::ConstantInitialized);

  inline DropRoleStmt(const DropRoleStmt& from)
      : DropRoleStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DropRoleStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DropRoleStmt* internal_default_instance() {
    return reinterpret_cast<const DropRoleStmt*>(
               &_DropRoleStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    177;

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

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

  DropRoleStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DropRoleStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DropRoleStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DropRoleStmt& from) {
    DropRoleStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DropRoleStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DropRoleStmt";
  }
  protected:
  explicit DropRoleStmt(::google::protobuf::Arena* arena);
  DropRoleStmt(::google::protobuf::Arena* arena, const DropRoleStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_roles();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_roles() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_roles();
  public:
  const ::pg_query::Node& roles(int index) const;
  ::pg_query::Node* add_roles();
  const ::google::protobuf::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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > roles_;
    bool missing_ok_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DropStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DropStmt) */ {
 public:
  inline DropStmt() : DropStmt(nullptr) {}
  ~DropStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DropStmt(::google::protobuf::internal::ConstantInitialized);

  inline DropStmt(const DropStmt& from)
      : DropStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DropStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DropStmt* internal_default_instance() {
    return reinterpret_cast<const DropStmt*>(
               &_DropStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    186;

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

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

  DropStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DropStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DropStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DropStmt& from) {
    DropStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DropStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DropStmt";
  }
  protected:
  explicit DropStmt(::google::protobuf::Arena* arena);
  DropStmt(::google::protobuf::Arena* arena, const DropStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_objects();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_objects() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_objects();
  public:
  const ::pg_query::Node& objects(int index) const;
  ::pg_query::Node* add_objects();
  const ::google::protobuf::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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > objects_;
    int remove_type_;
    int behavior_;
    bool missing_ok_;
    bool concurrent_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class DropdbStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.DropdbStmt) */ {
 public:
  inline DropdbStmt() : DropdbStmt(nullptr) {}
  ~DropdbStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR DropdbStmt(::google::protobuf::internal::ConstantInitialized);

  inline DropdbStmt(const DropdbStmt& from)
      : DropdbStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DropdbStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const DropdbStmt* internal_default_instance() {
    return reinterpret_cast<const DropdbStmt*>(
               &_DropdbStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    225;

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

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

  DropdbStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DropdbStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DropdbStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const DropdbStmt& from) {
    DropdbStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DropdbStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.DropdbStmt";
  }
  protected:
  explicit DropdbStmt(::google::protobuf::Arena* arena);
  DropdbStmt(::google::protobuf::Arena* arena, const DropdbStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string dbname = 1 [json_name = "dbname"];
  void clear_dbname() ;
  const std::string& dbname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_dbname(Arg_&& arg, Args_... args);
  std::string* mutable_dbname();
  PROTOBUF_NODISCARD std::string* release_dbname();
  void set_allocated_dbname(std::string* value);

  private:
  const std::string& _internal_dbname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      34, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr dbname_;
    bool missing_ok_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ExecuteStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ExecuteStmt) */ {
 public:
  inline ExecuteStmt() : ExecuteStmt(nullptr) {}
  ~ExecuteStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ExecuteStmt(::google::protobuf::internal::ConstantInitialized);

  inline ExecuteStmt(const ExecuteStmt& from)
      : ExecuteStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ExecuteStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExecuteStmt* internal_default_instance() {
    return reinterpret_cast<const ExecuteStmt*>(
               &_ExecuteStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    242;

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

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

  ExecuteStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExecuteStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ExecuteStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ExecuteStmt& from) {
    ExecuteStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ExecuteStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ExecuteStmt";
  }
  protected:
  explicit ExecuteStmt(::google::protobuf::Arena* arena);
  ExecuteStmt(::google::protobuf::Arena* arena, const ExecuteStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_params();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_params() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_params();
  public:
  const ::pg_query::Node& params(int index) const;
  ::pg_query::Node* add_params();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      params() const;
  // string name = 1 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      33, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > params_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ExplainStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ExplainStmt) */ {
 public:
  inline ExplainStmt() : ExplainStmt(nullptr) {}
  ~ExplainStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ExplainStmt(::google::protobuf::internal::ConstantInitialized);

  inline ExplainStmt(const ExplainStmt& from)
      : ExplainStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ExplainStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExplainStmt* internal_default_instance() {
    return reinterpret_cast<const ExplainStmt*>(
               &_ExplainStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    230;

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

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

  ExplainStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExplainStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ExplainStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ExplainStmt& from) {
    ExplainStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ExplainStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ExplainStmt";
  }
  protected:
  explicit ExplainStmt(::google::protobuf::Arena* arena);
  ExplainStmt(::google::protobuf::Arena* arena, const ExplainStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // .pg_query.Node query = 1 [json_name = "query"];
  bool has_query() const;
  void clear_query() ;
  const ::pg_query::Node& query() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* value);
  void unsafe_arena_set_allocated_query(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_query();

  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::pg_query::Node* query_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class FieldSelect final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.FieldSelect) */ {
 public:
  inline FieldSelect() : FieldSelect(nullptr) {}
  ~FieldSelect() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR FieldSelect(::google::protobuf::internal::ConstantInitialized);

  inline FieldSelect(const FieldSelect& from)
      : FieldSelect(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FieldSelect& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FieldSelect* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  FieldSelect* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FieldSelect>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const FieldSelect& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const FieldSelect& from) {
    FieldSelect::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(FieldSelect* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.FieldSelect";
  }
  protected:
  explicit FieldSelect(::google::protobuf::Arena* arena);
  FieldSelect(::google::protobuf::Arena* arena, const FieldSelect& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

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

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // int32 fieldnum = 3 [json_name = "fieldnum"];
  void clear_fieldnum() ;
  ::int32_t fieldnum() const;
  void set_fieldnum(::int32_t value);

  private:
  ::int32_t _internal_fieldnum() const;
  void _internal_set_fieldnum(::int32_t value);

  public:
  // uint32 resulttype = 4 [json_name = "resulttype"];
  void clear_resulttype() ;
  ::uint32_t resulttype() const;
  void set_resulttype(::uint32_t value);

  private:
  ::uint32_t _internal_resulttype() const;
  void _internal_set_resulttype(::uint32_t value);

  public:
  // int32 resulttypmod = 5 [json_name = "resulttypmod"];
  void clear_resulttypmod() ;
  ::int32_t resulttypmod() const;
  void set_resulttypmod(::int32_t value);

  private:
  ::int32_t _internal_resulttypmod() const;
  void _internal_set_resulttypmod(::int32_t value);

  public:
  // uint32 resultcollid = 6 [json_name = "resultcollid"];
  void clear_resultcollid() ;
  ::uint32_t resultcollid() const;
  void set_resultcollid(::uint32_t value);

  private:
  ::uint32_t _internal_resultcollid() const;
  void _internal_set_resultcollid(::uint32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* arg_;
    ::int32_t fieldnum_;
    ::uint32_t resulttype_;
    ::int32_t resulttypmod_;
    ::uint32_t resultcollid_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class FieldStore final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.FieldStore) */ {
 public:
  inline FieldStore() : FieldStore(nullptr) {}
  ~FieldStore() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR FieldStore(::google::protobuf::internal::ConstantInitialized);

  inline FieldStore(const FieldStore& from)
      : FieldStore(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FieldStore& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FieldStore* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  FieldStore* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FieldStore>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const FieldStore& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const FieldStore& from) {
    FieldStore::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(FieldStore* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.FieldStore";
  }
  protected:
  explicit FieldStore(::google::protobuf::Arena* arena);
  FieldStore(::google::protobuf::Arena* arena, const FieldStore& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_newvals();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_newvals() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_newvals();
  public:
  const ::pg_query::Node& newvals(int index) const;
  ::pg_query::Node* add_newvals();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_fieldnums();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_fieldnums() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_fieldnums();
  public:
  const ::pg_query::Node& fieldnums(int index) const;
  ::pg_query::Node* add_fieldnums();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      fieldnums() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

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

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // uint32 resulttype = 5 [json_name = "resulttype"];
  void clear_resulttype() ;
  ::uint32_t resulttype() const;
  void set_resulttype(::uint32_t value);

  private:
  ::uint32_t _internal_resulttype() const;
  void _internal_set_resulttype(::uint32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 4,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > newvals_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > fieldnums_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* arg_;
    ::uint32_t resulttype_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class FromExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.FromExpr) */ {
 public:
  inline FromExpr() : FromExpr(nullptr) {}
  ~FromExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR FromExpr(::google::protobuf::internal::ConstantInitialized);

  inline FromExpr(const FromExpr& from)
      : FromExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FromExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const FromExpr* internal_default_instance() {
    return reinterpret_cast<const FromExpr*>(
               &_FromExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    65;

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

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

  FromExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FromExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const FromExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const FromExpr& from) {
    FromExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(FromExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.FromExpr";
  }
  protected:
  explicit FromExpr(::google::protobuf::Arena* arena);
  FromExpr(::google::protobuf::Arena* arena, const FromExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_fromlist();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_fromlist() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_fromlist();
  public:
  const ::pg_query::Node& fromlist(int index) const;
  ::pg_query::Node* add_fromlist();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      fromlist() const;
  // .pg_query.Node quals = 2 [json_name = "quals"];
  bool has_quals() const;
  void clear_quals() ;
  const ::pg_query::Node& quals() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_quals();
  ::pg_query::Node* mutable_quals();
  void set_allocated_quals(::pg_query::Node* value);
  void unsafe_arena_set_allocated_quals(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_quals();

  private:
  const ::pg_query::Node& _internal_quals() const;
  ::pg_query::Node* _internal_mutable_quals();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > fromlist_;
    ::pg_query::Node* quals_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class FuncCall final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.FuncCall) */ {
 public:
  inline FuncCall() : FuncCall(nullptr) {}
  ~FuncCall() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR FuncCall(::google::protobuf::internal::ConstantInitialized);

  inline FuncCall(const FuncCall& from)
      : FuncCall(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FuncCall& default_instance() {
    return *internal_default_instance();
  }
  static inline const FuncCall* internal_default_instance() {
    return reinterpret_cast<const FuncCall*>(
               &_FuncCall_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    75;

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

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

  FuncCall* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FuncCall>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const FuncCall& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const FuncCall& from) {
    FuncCall::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(FuncCall* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.FuncCall";
  }
  protected:
  explicit FuncCall(::google::protobuf::Arena* arena);
  FuncCall(::google::protobuf::Arena* arena, const FuncCall& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kFuncnameFieldNumber = 1,
    kArgsFieldNumber = 2,
    kAggOrderFieldNumber = 3,
    kAggFilterFieldNumber = 4,
    kOverFieldNumber = 5,
    kAggWithinGroupFieldNumber = 6,
    kAggStarFieldNumber = 7,
    kAggDistinctFieldNumber = 8,
    kFuncVariadicFieldNumber = 9,
    kFuncformatFieldNumber = 10,
    kLocationFieldNumber = 11,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_funcname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_funcname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_funcname();
  public:
  const ::pg_query::Node& funcname(int index) const;
  ::pg_query::Node* add_funcname();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_agg_order();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_agg_order() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_agg_order();
  public:
  const ::pg_query::Node& agg_order(int index) const;
  ::pg_query::Node* add_agg_order();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      agg_order() const;
  // .pg_query.Node agg_filter = 4 [json_name = "agg_filter"];
  bool has_agg_filter() const;
  void clear_agg_filter() ;
  const ::pg_query::Node& agg_filter() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_agg_filter();
  ::pg_query::Node* mutable_agg_filter();
  void set_allocated_agg_filter(::pg_query::Node* value);
  void unsafe_arena_set_allocated_agg_filter(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_agg_filter();

  private:
  const ::pg_query::Node& _internal_agg_filter() const;
  ::pg_query::Node* _internal_mutable_agg_filter();

  public:
  // .pg_query.WindowDef over = 5 [json_name = "over"];
  bool has_over() const;
  void clear_over() ;
  const ::pg_query::WindowDef& over() const;
  PROTOBUF_NODISCARD ::pg_query::WindowDef* release_over();
  ::pg_query::WindowDef* mutable_over();
  void set_allocated_over(::pg_query::WindowDef* value);
  void unsafe_arena_set_allocated_over(::pg_query::WindowDef* value);
  ::pg_query::WindowDef* unsafe_arena_release_over();

  private:
  const ::pg_query::WindowDef& _internal_over() const;
  ::pg_query::WindowDef* _internal_mutable_over();

  public:
  // bool agg_within_group = 6 [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 = 7 [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 = 8 [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 = 9 [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:
  // .pg_query.CoercionForm funcformat = 10 [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:
  // int32 location = 11 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 11, 5,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > funcname_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::google::protobuf::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_;
    int funcformat_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class FuncExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.FuncExpr) */ {
 public:
  inline FuncExpr() : FuncExpr(nullptr) {}
  ~FuncExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR FuncExpr(::google::protobuf::internal::ConstantInitialized);

  inline FuncExpr(const FuncExpr& from)
      : FuncExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FuncExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FuncExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  FuncExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FuncExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const FuncExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const FuncExpr& from) {
    FuncExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(FuncExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.FuncExpr";
  }
  protected:
  explicit FuncExpr(::google::protobuf::Arena* arena);
  FuncExpr(::google::protobuf::Arena* arena, const FuncExpr& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 funcid = 2 [json_name = "funcid"];
  void clear_funcid() ;
  ::uint32_t funcid() const;
  void set_funcid(::uint32_t value);

  private:
  ::uint32_t _internal_funcid() const;
  void _internal_set_funcid(::uint32_t value);

  public:
  // uint32 funcresulttype = 3 [json_name = "funcresulttype"];
  void clear_funcresulttype() ;
  ::uint32_t funcresulttype() const;
  void set_funcresulttype(::uint32_t value);

  private:
  ::uint32_t _internal_funcresulttype() const;
  void _internal_set_funcresulttype(::uint32_t 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() ;
  ::uint32_t funccollid() const;
  void set_funccollid(::uint32_t value);

  private:
  ::uint32_t _internal_funccollid() const;
  void _internal_set_funccollid(::uint32_t value);

  public:
  // uint32 inputcollid = 8 [json_name = "inputcollid"];
  void clear_inputcollid() ;
  ::uint32_t inputcollid() const;
  void set_inputcollid(::uint32_t value);

  private:
  ::uint32_t _internal_inputcollid() const;
  void _internal_set_inputcollid(::uint32_t value);

  public:
  // int32 location = 10 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 10, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* xpr_;
    ::uint32_t funcid_;
    ::uint32_t funcresulttype_;
    bool funcretset_;
    bool funcvariadic_;
    int funcformat_;
    ::uint32_t funccollid_;
    ::uint32_t inputcollid_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class FunctionParameter final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.FunctionParameter) */ {
 public:
  inline FunctionParameter() : FunctionParameter(nullptr) {}
  ~FunctionParameter() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR FunctionParameter(::google::protobuf::internal::ConstantInitialized);

  inline FunctionParameter(const FunctionParameter& from)
      : FunctionParameter(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const FunctionParameter* internal_default_instance() {
    return reinterpret_cast<const FunctionParameter*>(
               &_FunctionParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    198;

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

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

  FunctionParameter* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionParameter>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const FunctionParameter& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const FunctionParameter& from) {
    FunctionParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(FunctionParameter* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.FunctionParameter";
  }
  protected:
  explicit FunctionParameter(::google::protobuf::Arena* arena);
  FunctionParameter(::google::protobuf::Arena* arena, const FunctionParameter& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .pg_query.TypeName arg_type = 2 [json_name = "argType"];
  bool has_arg_type() const;
  void clear_arg_type() ;
  const ::pg_query::TypeName& arg_type() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_arg_type();
  ::pg_query::TypeName* mutable_arg_type();
  void set_allocated_arg_type(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_arg_type(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_arg_type();

  private:
  const ::pg_query::TypeName& _internal_arg_type() const;
  ::pg_query::TypeName* _internal_mutable_arg_type();

  public:
  // .pg_query.Node defexpr = 4 [json_name = "defexpr"];
  bool has_defexpr() const;
  void clear_defexpr() ;
  const ::pg_query::Node& defexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_defexpr();
  ::pg_query::Node* mutable_defexpr();
  void set_allocated_defexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_defexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_defexpr();

  private:
  const ::pg_query::Node& _internal_defexpr() const;
  ::pg_query::Node* _internal_mutable_defexpr();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      39, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::pg_query::TypeName* arg_type_;
    ::pg_query::Node* defexpr_;
    int mode_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class GrantRoleStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.GrantRoleStmt) */ {
 public:
  inline GrantRoleStmt() : GrantRoleStmt(nullptr) {}
  ~GrantRoleStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GrantRoleStmt(::google::protobuf::internal::ConstantInitialized);

  inline GrantRoleStmt(const GrantRoleStmt& from)
      : GrantRoleStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const GrantRoleStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const GrantRoleStmt* internal_default_instance() {
    return reinterpret_cast<const GrantRoleStmt*>(
               &_GrantRoleStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    144;

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

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

  GrantRoleStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GrantRoleStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const GrantRoleStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const GrantRoleStmt& from) {
    GrantRoleStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrantRoleStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.GrantRoleStmt";
  }
  protected:
  explicit GrantRoleStmt(::google::protobuf::Arena* arena);
  GrantRoleStmt(::google::protobuf::Arena* arena, const GrantRoleStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kGrantedRolesFieldNumber = 1,
    kGranteeRolesFieldNumber = 2,
    kOptFieldNumber = 4,
    kGrantorFieldNumber = 5,
    kIsGrantFieldNumber = 3,
    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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_granted_roles();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_granted_roles() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_granted_roles();
  public:
  const ::pg_query::Node& granted_roles(int index) const;
  ::pg_query::Node* add_granted_roles();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_grantee_roles();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_grantee_roles() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_grantee_roles();
  public:
  const ::pg_query::Node& grantee_roles(int index) const;
  ::pg_query::Node* add_grantee_roles();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      grantee_roles() const;
  // repeated .pg_query.Node opt = 4 [json_name = "opt"];
  int opt_size() const;
  private:
  int _internal_opt_size() const;

  public:
  void clear_opt() ;
  ::pg_query::Node* mutable_opt(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_opt();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_opt() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_opt();
  public:
  const ::pg_query::Node& opt(int index) const;
  ::pg_query::Node* add_opt();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      opt() const;
  // .pg_query.RoleSpec grantor = 5 [json_name = "grantor"];
  bool has_grantor() const;
  void clear_grantor() ;
  const ::pg_query::RoleSpec& grantor() const;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_grantor();
  ::pg_query::RoleSpec* mutable_grantor();
  void set_allocated_grantor(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_grantor(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_grantor();

  private:
  const ::pg_query::RoleSpec& _internal_grantor() const;
  ::pg_query::RoleSpec* _internal_mutable_grantor();

  public:
  // 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:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 4,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > granted_roles_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > grantee_roles_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > opt_;
    ::pg_query::RoleSpec* grantor_;
    bool is_grant_;
    int behavior_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class GrantStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.GrantStmt) */ {
 public:
  inline GrantStmt() : GrantStmt(nullptr) {}
  ~GrantStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GrantStmt(::google::protobuf::internal::ConstantInitialized);

  inline GrantStmt(const GrantStmt& from)
      : GrantStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const GrantStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const GrantStmt* internal_default_instance() {
    return reinterpret_cast<const GrantStmt*>(
               &_GrantStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    141;

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

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

  GrantStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GrantStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const GrantStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const GrantStmt& from) {
    GrantStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrantStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.GrantStmt";
  }
  protected:
  explicit GrantStmt(::google::protobuf::Arena* arena);
  GrantStmt(::google::protobuf::Arena* arena, const GrantStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kObjectsFieldNumber = 4,
    kPrivilegesFieldNumber = 5,
    kGranteesFieldNumber = 6,
    kGrantorFieldNumber = 8,
    kTargtypeFieldNumber = 2,
    kObjtypeFieldNumber = 3,
    kIsGrantFieldNumber = 1,
    kGrantOptionFieldNumber = 7,
    kBehaviorFieldNumber = 9,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_objects();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_objects() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_objects();
  public:
  const ::pg_query::Node& objects(int index) const;
  ::pg_query::Node* add_objects();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_privileges();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_privileges() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_privileges();
  public:
  const ::pg_query::Node& privileges(int index) const;
  ::pg_query::Node* add_privileges();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_grantees();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_grantees() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_grantees();
  public:
  const ::pg_query::Node& grantees(int index) const;
  ::pg_query::Node* add_grantees();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      grantees() const;
  // .pg_query.RoleSpec grantor = 8 [json_name = "grantor"];
  bool has_grantor() const;
  void clear_grantor() ;
  const ::pg_query::RoleSpec& grantor() const;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_grantor();
  ::pg_query::RoleSpec* mutable_grantor();
  void set_allocated_grantor(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_grantor(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_grantor();

  private:
  const ::pg_query::RoleSpec& _internal_grantor() const;
  ::pg_query::RoleSpec* _internal_mutable_grantor();

  public:
  // .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 = 9 [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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 9, 4,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > objects_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > privileges_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > grantees_;
    ::pg_query::RoleSpec* grantor_;
    int targtype_;
    int objtype_;
    bool is_grant_;
    bool grant_option_;
    int behavior_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class GroupingFunc final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.GroupingFunc) */ {
 public:
  inline GroupingFunc() : GroupingFunc(nullptr) {}
  ~GroupingFunc() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GroupingFunc(::google::protobuf::internal::ConstantInitialized);

  inline GroupingFunc(const GroupingFunc& from)
      : GroupingFunc(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const GroupingFunc& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GroupingFunc* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  GroupingFunc* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupingFunc>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const GroupingFunc& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const GroupingFunc& from) {
    GroupingFunc::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GroupingFunc* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.GroupingFunc";
  }
  protected:
  explicit GroupingFunc(::google::protobuf::Arena* arena);
  GroupingFunc(::google::protobuf::Arena* arena, const GroupingFunc& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  enum : int {
    kArgsFieldNumber = 2,
    kRefsFieldNumber = 3,
    kXprFieldNumber = 1,
    kAgglevelsupFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_refs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_refs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_refs();
  public:
  const ::pg_query::Node& refs(int index) const;
  ::pg_query::Node* add_refs();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      refs() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 agglevelsup = 4 [json_name = "agglevelsup"];
  void clear_agglevelsup() ;
  ::uint32_t agglevelsup() const;
  void set_agglevelsup(::uint32_t value);

  private:
  ::uint32_t _internal_agglevelsup() const;
  void _internal_set_agglevelsup(::uint32_t value);

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > refs_;
    ::pg_query::Node* xpr_;
    ::uint32_t agglevelsup_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class GroupingSet final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.GroupingSet) */ {
 public:
  inline GroupingSet() : GroupingSet(nullptr) {}
  ~GroupingSet() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GroupingSet(::google::protobuf::internal::ConstantInitialized);

  inline GroupingSet(const GroupingSet& from)
      : GroupingSet(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const GroupingSet& default_instance() {
    return *internal_default_instance();
  }
  static inline const GroupingSet* internal_default_instance() {
    return reinterpret_cast<const GroupingSet*>(
               &_GroupingSet_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    106;

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

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

  GroupingSet* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupingSet>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const GroupingSet& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const GroupingSet& from) {
    GroupingSet::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GroupingSet* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.GroupingSet";
  }
  protected:
  explicit GroupingSet(::google::protobuf::Arena* arena);
  GroupingSet(::google::protobuf::Arena* arena, const GroupingSet& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_content();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_content() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_content();
  public:
  const ::pg_query::Node& content(int index) const;
  ::pg_query::Node* add_content();
  const ::google::protobuf::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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > content_;
    int kind_;
    ::int32_t location_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ImportForeignSchemaStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ImportForeignSchemaStmt) */ {
 public:
  inline ImportForeignSchemaStmt() : ImportForeignSchemaStmt(nullptr) {}
  ~ImportForeignSchemaStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ImportForeignSchemaStmt(::google::protobuf::internal::ConstantInitialized);

  inline ImportForeignSchemaStmt(const ImportForeignSchemaStmt& from)
      : ImportForeignSchemaStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ImportForeignSchemaStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ImportForeignSchemaStmt* internal_default_instance() {
    return reinterpret_cast<const ImportForeignSchemaStmt*>(
               &_ImportForeignSchemaStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    166;

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

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

  ImportForeignSchemaStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ImportForeignSchemaStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ImportForeignSchemaStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ImportForeignSchemaStmt& from) {
    ImportForeignSchemaStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ImportForeignSchemaStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ImportForeignSchemaStmt";
  }
  protected:
  explicit ImportForeignSchemaStmt(::google::protobuf::Arena* arena);
  ImportForeignSchemaStmt(::google::protobuf::Arena* arena, const ImportForeignSchemaStmt& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_table_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_table_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_table_list();
  public:
  const ::pg_query::Node& table_list(int index) const;
  ::pg_query::Node* add_table_list();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string server_name = 1 [json_name = "server_name"];
  void clear_server_name() ;
  const std::string& server_name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_server_name(Arg_&& arg, Args_... args);
  std::string* mutable_server_name();
  PROTOBUF_NODISCARD std::string* release_server_name();
  void set_allocated_server_name(std::string* value);

  private:
  const std::string& _internal_server_name() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_remote_schema(Arg_&& arg, Args_... args);
  std::string* mutable_remote_schema();
  PROTOBUF_NODISCARD std::string* release_remote_schema();
  void set_allocated_remote_schema(std::string* value);

  private:
  const std::string& _internal_remote_schema() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_local_schema(Arg_&& arg, Args_... args);
  std::string* mutable_local_schema();
  PROTOBUF_NODISCARD std::string* release_local_schema();
  void set_allocated_local_schema(std::string* value);

  private:
  const std::string& _internal_local_schema() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 2,
      77, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > table_list_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr server_name_;
    ::google::protobuf::internal::ArenaStringPtr remote_schema_;
    ::google::protobuf::internal::ArenaStringPtr local_schema_;
    int list_type_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class IndexElem final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.IndexElem) */ {
 public:
  inline IndexElem() : IndexElem(nullptr) {}
  ~IndexElem() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR IndexElem(::google::protobuf::internal::ConstantInitialized);

  inline IndexElem(const IndexElem& from)
      : IndexElem(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const IndexElem& default_instance() {
    return *internal_default_instance();
  }
  static inline const IndexElem* internal_default_instance() {
    return reinterpret_cast<const IndexElem*>(
               &_IndexElem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    91;

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

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

  IndexElem* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IndexElem>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const IndexElem& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const IndexElem& from) {
    IndexElem::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(IndexElem* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.IndexElem";
  }
  protected:
  explicit IndexElem(::google::protobuf::Arena* arena);
  IndexElem(::google::protobuf::Arena* arena, const IndexElem& from);
  public:

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

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_collation();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_collation() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_collation();
  public:
  const ::pg_query::Node& collation(int index) const;
  ::pg_query::Node* add_collation();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_opclass();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_opclass() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_opclass();
  public:
  const ::pg_query::Node& opclass(int index) const;
  ::pg_query::Node* add_opclass();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_opclassopts();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_opclassopts() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_opclassopts();
  public:
  const ::pg_query::Node& opclassopts(int index) const;
  ::pg_query::Node* add_opclassopts();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      opclassopts() const;
  // string name = 1 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // string indexcolname = 3 [json_name = "indexcolname"];
  void clear_indexcolname() ;
  const std::string& indexcolname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_indexcolname(Arg_&& arg, Args_... args);
  std::string* mutable_indexcolname();
  PROTOBUF_NODISCARD std::string* release_indexcolname();
  void set_allocated_indexcolname(std::string* value);

  private:
  const std::string& _internal_indexcolname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_expr() ;
  const ::pg_query::Node& expr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_expr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_expr();

  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 4,
      51, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > collation_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > opclass_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > opclassopts_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr indexcolname_;
    ::pg_query::Node* expr_;
    int ordering_;
    int nulls_ordering_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class IndexStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.IndexStmt) */ {
 public:
  inline IndexStmt() : IndexStmt(nullptr) {}
  ~IndexStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR IndexStmt(::google::protobuf::internal::ConstantInitialized);

  inline IndexStmt(const IndexStmt& from)
      : IndexStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const IndexStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const IndexStmt* internal_default_instance() {
    return reinterpret_cast<const IndexStmt*>(
               &_IndexStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    193;

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

  // implements Message ----------------------------------------------

  IndexStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IndexStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const IndexStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const IndexStmt& from) {
    IndexStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(IndexStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.IndexStmt";
  }
  protected:
  explicit IndexStmt(::google::protobuf::Arena* arena);
  IndexStmt(::google::protobuf::Arena* arena, const IndexStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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,
    kOldNumberFieldNumber = 12,
    kOldCreateSubidFieldNumber = 13,
    kOldFirstRelfilelocatorSubidFieldNumber = 14,
    kUniqueFieldNumber = 15,
    kNullsNotDistinctFieldNumber = 16,
    kPrimaryFieldNumber = 17,
    kIsconstraintFieldNumber = 18,
    kDeferrableFieldNumber = 19,
    kInitdeferredFieldNumber = 20,
    kTransformedFieldNumber = 21,
    kConcurrentFieldNumber = 22,
    kIfNotExistsFieldNumber = 23,
    kResetDefaultTblspcFieldNumber = 24,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_index_params();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_index_params() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_index_params();
  public:
  const ::pg_query::Node& index_params(int index) const;
  ::pg_query::Node* add_index_params();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_index_including_params();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_index_including_params() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_index_including_params();
  public:
  const ::pg_query::Node& index_including_params(int index) const;
  ::pg_query::Node* add_index_including_params();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_exclude_op_names();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_exclude_op_names() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_exclude_op_names();
  public:
  const ::pg_query::Node& exclude_op_names(int index) const;
  ::pg_query::Node* add_exclude_op_names();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      exclude_op_names() const;
  // string idxname = 1 [json_name = "idxname"];
  void clear_idxname() ;
  const std::string& idxname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_idxname(Arg_&& arg, Args_... args);
  std::string* mutable_idxname();
  PROTOBUF_NODISCARD std::string* release_idxname();
  void set_allocated_idxname(std::string* value);

  private:
  const std::string& _internal_idxname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_access_method(Arg_&& arg, Args_... args);
  std::string* mutable_access_method();
  PROTOBUF_NODISCARD std::string* release_access_method();
  void set_allocated_access_method(std::string* value);

  private:
  const std::string& _internal_access_method() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_table_space(Arg_&& arg, Args_... args);
  std::string* mutable_table_space();
  PROTOBUF_NODISCARD std::string* release_table_space();
  void set_allocated_table_space(std::string* value);

  private:
  const std::string& _internal_table_space() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_idxcomment(Arg_&& arg, Args_... args);
  std::string* mutable_idxcomment();
  PROTOBUF_NODISCARD std::string* release_idxcomment();
  void set_allocated_idxcomment(std::string* value);

  private:
  const std::string& _internal_idxcomment() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node where_clause = 8 [json_name = "whereClause"];
  bool has_where_clause() const;
  void clear_where_clause() ;
  const ::pg_query::Node& where_clause() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* value);
  void unsafe_arena_set_allocated_where_clause(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();

  public:
  // uint32 index_oid = 11 [json_name = "indexOid"];
  void clear_index_oid() ;
  ::uint32_t index_oid() const;
  void set_index_oid(::uint32_t value);

  private:
  ::uint32_t _internal_index_oid() const;
  void _internal_set_index_oid(::uint32_t value);

  public:
  // uint32 old_number = 12 [json_name = "oldNumber"];
  void clear_old_number() ;
  ::uint32_t old_number() const;
  void set_old_number(::uint32_t value);

  private:
  ::uint32_t _internal_old_number() const;
  void _internal_set_old_number(::uint32_t value);

  public:
  // uint32 old_create_subid = 13 [json_name = "oldCreateSubid"];
  void clear_old_create_subid() ;
  ::uint32_t old_create_subid() const;
  void set_old_create_subid(::uint32_t value);

  private:
  ::uint32_t _internal_old_create_subid() const;
  void _internal_set_old_create_subid(::uint32_t value);

  public:
  // uint32 old_first_relfilelocator_subid = 14 [json_name = "oldFirstRelfilelocatorSubid"];
  void clear_old_first_relfilelocator_subid() ;
  ::uint32_t old_first_relfilelocator_subid() const;
  void set_old_first_relfilelocator_subid(::uint32_t value);

  private:
  ::uint32_t _internal_old_first_relfilelocator_subid() const;
  void _internal_set_old_first_relfilelocator_subid(::uint32_t 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 nulls_not_distinct = 16 [json_name = "nulls_not_distinct"];
  void clear_nulls_not_distinct() ;
  bool nulls_not_distinct() const;
  void set_nulls_not_distinct(bool value);

  private:
  bool _internal_nulls_not_distinct() const;
  void _internal_set_nulls_not_distinct(bool value);

  public:
  // bool primary = 17 [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 = 18 [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 = 19 [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 = 20 [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 = 21 [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 = 22 [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 = 23 [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 = 24 [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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      5, 24, 6,
      92, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > index_params_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > index_including_params_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > exclude_op_names_;
    ::google::protobuf::internal::ArenaStringPtr idxname_;
    ::google::protobuf::internal::ArenaStringPtr access_method_;
    ::google::protobuf::internal::ArenaStringPtr table_space_;
    ::google::protobuf::internal::ArenaStringPtr idxcomment_;
    ::pg_query::RangeVar* relation_;
    ::pg_query::Node* where_clause_;
    ::uint32_t index_oid_;
    ::uint32_t old_number_;
    ::uint32_t old_create_subid_;
    ::uint32_t old_first_relfilelocator_subid_;
    bool unique_;
    bool nulls_not_distinct_;
    bool primary_;
    bool isconstraint_;
    bool deferrable_;
    bool initdeferred_;
    bool transformed_;
    bool concurrent_;
    bool if_not_exists_;
    bool reset_default_tblspc_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class InferClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.InferClause) */ {
 public:
  inline InferClause() : InferClause(nullptr) {}
  ~InferClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR InferClause(::google::protobuf::internal::ConstantInitialized);

  inline InferClause(const InferClause& from)
      : InferClause(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const InferClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const InferClause* internal_default_instance() {
    return reinterpret_cast<const InferClause*>(
               &_InferClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    110;

  friend void swap(InferClause& a, InferClause& b) {
    a.Swap(&b);
  }
  inline void Swap(InferClause* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InferClause* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  InferClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InferClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const InferClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const InferClause& from) {
    InferClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(InferClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.InferClause";
  }
  protected:
  explicit InferClause(::google::protobuf::Arena* arena);
  InferClause(::google::protobuf::Arena* arena, const InferClause& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_index_elems();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_index_elems() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_index_elems();
  public:
  const ::pg_query::Node& index_elems(int index) const;
  ::pg_query::Node* add_index_elems();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      index_elems() const;
  // string conname = 3 [json_name = "conname"];
  void clear_conname() ;
  const std::string& conname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_conname(Arg_&& arg, Args_... args);
  std::string* mutable_conname();
  PROTOBUF_NODISCARD std::string* release_conname();
  void set_allocated_conname(std::string* value);

  private:
  const std::string& _internal_conname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_where_clause() ;
  const ::pg_query::Node& where_clause() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* value);
  void unsafe_arena_set_allocated_where_clause(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();

  public:
  // int32 location = 4 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.InferClause)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      36, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > index_elems_;
    ::google::protobuf::internal::ArenaStringPtr conname_;
    ::pg_query::Node* where_clause_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class InferenceElem final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.InferenceElem) */ {
 public:
  inline InferenceElem() : InferenceElem(nullptr) {}
  ~InferenceElem() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR InferenceElem(::google::protobuf::internal::ConstantInitialized);

  inline InferenceElem(const InferenceElem& from)
      : InferenceElem(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const InferenceElem& default_instance() {
    return *internal_default_instance();
  }
  static inline const InferenceElem* internal_default_instance() {
    return reinterpret_cast<const InferenceElem*>(
               &_InferenceElem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    61;

  friend void swap(InferenceElem& a, InferenceElem& b) {
    a.Swap(&b);
  }
  inline void Swap(InferenceElem* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InferenceElem* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  InferenceElem* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InferenceElem>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const InferenceElem& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const InferenceElem& from) {
    InferenceElem::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(InferenceElem* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.InferenceElem";
  }
  protected:
  explicit InferenceElem(::google::protobuf::Arena* arena);
  InferenceElem(::google::protobuf::Arena* arena, const InferenceElem& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node expr = 2 [json_name = "expr"];
  bool has_expr() const;
  void clear_expr() ;
  const ::pg_query::Node& expr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_expr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_expr();

  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();

  public:
  // uint32 infercollid = 3 [json_name = "infercollid"];
  void clear_infercollid() ;
  ::uint32_t infercollid() const;
  void set_infercollid(::uint32_t value);

  private:
  ::uint32_t _internal_infercollid() const;
  void _internal_set_infercollid(::uint32_t value);

  public:
  // uint32 inferopclass = 4 [json_name = "inferopclass"];
  void clear_inferopclass() ;
  ::uint32_t inferopclass() const;
  void set_inferopclass(::uint32_t value);

  private:
  ::uint32_t _internal_inferopclass() const;
  void _internal_set_inferopclass(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.InferenceElem)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* expr_;
    ::uint32_t infercollid_;
    ::uint32_t inferopclass_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class InsertStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.InsertStmt) */ {
 public:
  inline InsertStmt() : InsertStmt(nullptr) {}
  ~InsertStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR InsertStmt(::google::protobuf::internal::ConstantInitialized);

  inline InsertStmt(const InsertStmt& from)
      : InsertStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const InsertStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const InsertStmt* internal_default_instance() {
    return reinterpret_cast<const InsertStmt*>(
               &_InsertStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    127;

  friend void swap(InsertStmt& a, InsertStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(InsertStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InsertStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  InsertStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InsertStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const InsertStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const InsertStmt& from) {
    InsertStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(InsertStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.InsertStmt";
  }
  protected:
  explicit InsertStmt(::google::protobuf::Arena* arena);
  InsertStmt(::google::protobuf::Arena* arena, const InsertStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_cols();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_cols() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_cols();
  public:
  const ::pg_query::Node& cols(int index) const;
  ::pg_query::Node* add_cols();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_returning_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_returning_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_returning_list();
  public:
  const ::pg_query::Node& returning_list(int index) const;
  ::pg_query::Node* add_returning_list();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      returning_list() const;
  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node select_stmt = 3 [json_name = "selectStmt"];
  bool has_select_stmt() const;
  void clear_select_stmt() ;
  const ::pg_query::Node& select_stmt() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_select_stmt();
  ::pg_query::Node* mutable_select_stmt();
  void set_allocated_select_stmt(::pg_query::Node* value);
  void unsafe_arena_set_allocated_select_stmt(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_select_stmt();

  private:
  const ::pg_query::Node& _internal_select_stmt() const;
  ::pg_query::Node* _internal_mutable_select_stmt();

  public:
  // .pg_query.OnConflictClause on_conflict_clause = 4 [json_name = "onConflictClause"];
  bool has_on_conflict_clause() const;
  void clear_on_conflict_clause() ;
  const ::pg_query::OnConflictClause& on_conflict_clause() const;
  PROTOBUF_NODISCARD ::pg_query::OnConflictClause* release_on_conflict_clause();
  ::pg_query::OnConflictClause* mutable_on_conflict_clause();
  void set_allocated_on_conflict_clause(::pg_query::OnConflictClause* value);
  void unsafe_arena_set_allocated_on_conflict_clause(::pg_query::OnConflictClause* value);
  ::pg_query::OnConflictClause* unsafe_arena_release_on_conflict_clause();

  private:
  const ::pg_query::OnConflictClause& _internal_on_conflict_clause() const;
  ::pg_query::OnConflictClause* _internal_mutable_on_conflict_clause();

  public:
  // .pg_query.WithClause with_clause = 6 [json_name = "withClause"];
  bool has_with_clause() const;
  void clear_with_clause() ;
  const ::pg_query::WithClause& with_clause() const;
  PROTOBUF_NODISCARD ::pg_query::WithClause* release_with_clause();
  ::pg_query::WithClause* mutable_with_clause();
  void set_allocated_with_clause(::pg_query::WithClause* value);
  void unsafe_arena_set_allocated_with_clause(::pg_query::WithClause* value);
  ::pg_query::WithClause* unsafe_arena_release_with_clause();

  private:
  const ::pg_query::WithClause& _internal_with_clause() const;
  ::pg_query::WithClause* _internal_mutable_with_clause();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 6,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > cols_;
    ::google::protobuf::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_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class IntList final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.IntList) */ {
 public:
  inline IntList() : IntList(nullptr) {}
  ~IntList() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR IntList(::google::protobuf::internal::ConstantInitialized);

  inline IntList(const IntList& from)
      : IntList(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const IntList& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IntList* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  IntList* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IntList>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const IntList& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const IntList& from) {
    IntList::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(IntList* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.IntList";
  }
  protected:
  explicit IntList(::google::protobuf::Arena* arena);
  IntList(::google::protobuf::Arena* arena, const IntList& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_items();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_items() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_items();
  public:
  const ::pg_query::Node& items(int index) const;
  ::pg_query::Node* add_items();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      items() const;
  // @@protoc_insertion_point(class_scope:pg_query.IntList)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > items_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class IntoClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.IntoClause) */ {
 public:
  inline IntoClause() : IntoClause(nullptr) {}
  ~IntoClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR IntoClause(::google::protobuf::internal::ConstantInitialized);

  inline IntoClause(const IntoClause& from)
      : IntoClause(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const IntoClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const IntoClause* internal_default_instance() {
    return reinterpret_cast<const IntoClause*>(
               &_IntoClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(IntoClause& a, IntoClause& b) {
    a.Swap(&b);
  }
  inline void Swap(IntoClause* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IntoClause* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  IntoClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IntoClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const IntoClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const IntoClause& from) {
    IntoClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(IntoClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.IntoClause";
  }
  protected:
  explicit IntoClause(::google::protobuf::Arena* arena);
  IntoClause(::google::protobuf::Arena* arena, const IntoClause& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_col_names();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_col_names() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_col_names();
  public:
  const ::pg_query::Node& col_names(int index) const;
  ::pg_query::Node* add_col_names();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string access_method = 3 [json_name = "accessMethod"];
  void clear_access_method() ;
  const std::string& access_method() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_access_method(Arg_&& arg, Args_... args);
  std::string* mutable_access_method();
  PROTOBUF_NODISCARD std::string* release_access_method();
  void set_allocated_access_method(std::string* value);

  private:
  const std::string& _internal_access_method() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_table_space_name(Arg_&& arg, Args_... args);
  std::string* mutable_table_space_name();
  PROTOBUF_NODISCARD std::string* release_table_space_name();
  void set_allocated_table_space_name(std::string* value);

  private:
  const std::string& _internal_table_space_name() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_rel() ;
  const ::pg_query::RangeVar& rel() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_rel();
  ::pg_query::RangeVar* mutable_rel();
  void set_allocated_rel(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_rel(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_rel();

  private:
  const ::pg_query::RangeVar& _internal_rel() const;
  ::pg_query::RangeVar* _internal_mutable_rel();

  public:
  // .pg_query.Node view_query = 7 [json_name = "viewQuery"];
  bool has_view_query() const;
  void clear_view_query() ;
  const ::pg_query::Node& view_query() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_view_query();
  ::pg_query::Node* mutable_view_query();
  void set_allocated_view_query(::pg_query::Node* value);
  void unsafe_arena_set_allocated_view_query(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_view_query();

  private:
  const ::pg_query::Node& _internal_view_query() const;
  ::pg_query::Node* _internal_mutable_view_query();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 4,
      65, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > col_names_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr access_method_;
    ::google::protobuf::internal::ArenaStringPtr table_space_name_;
    ::pg_query::RangeVar* rel_;
    ::pg_query::Node* view_query_;
    int on_commit_;
    bool skip_data_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JoinExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JoinExpr) */ {
 public:
  inline JoinExpr() : JoinExpr(nullptr) {}
  ~JoinExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JoinExpr(::google::protobuf::internal::ConstantInitialized);

  inline JoinExpr(const JoinExpr& from)
      : JoinExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JoinExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const JoinExpr* internal_default_instance() {
    return reinterpret_cast<const JoinExpr*>(
               &_JoinExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    64;

  friend void swap(JoinExpr& a, JoinExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(JoinExpr* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JoinExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  JoinExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JoinExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JoinExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JoinExpr& from) {
    JoinExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JoinExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JoinExpr";
  }
  protected:
  explicit JoinExpr(::google::protobuf::Arena* arena);
  JoinExpr(::google::protobuf::Arena* arena, const JoinExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kUsingClauseFieldNumber = 5,
    kLargFieldNumber = 3,
    kRargFieldNumber = 4,
    kJoinUsingAliasFieldNumber = 6,
    kQualsFieldNumber = 7,
    kAliasFieldNumber = 8,
    kJointypeFieldNumber = 1,
    kIsNaturalFieldNumber = 2,
    kRtindexFieldNumber = 9,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_using_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_using_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_using_clause();
  public:
  const ::pg_query::Node& using_clause(int index) const;
  ::pg_query::Node* add_using_clause();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      using_clause() const;
  // .pg_query.Node larg = 3 [json_name = "larg"];
  bool has_larg() const;
  void clear_larg() ;
  const ::pg_query::Node& larg() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_larg();
  ::pg_query::Node* mutable_larg();
  void set_allocated_larg(::pg_query::Node* value);
  void unsafe_arena_set_allocated_larg(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_larg();

  private:
  const ::pg_query::Node& _internal_larg() const;
  ::pg_query::Node* _internal_mutable_larg();

  public:
  // .pg_query.Node rarg = 4 [json_name = "rarg"];
  bool has_rarg() const;
  void clear_rarg() ;
  const ::pg_query::Node& rarg() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_rarg();
  ::pg_query::Node* mutable_rarg();
  void set_allocated_rarg(::pg_query::Node* value);
  void unsafe_arena_set_allocated_rarg(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_rarg();

  private:
  const ::pg_query::Node& _internal_rarg() const;
  ::pg_query::Node* _internal_mutable_rarg();

  public:
  // .pg_query.Alias join_using_alias = 6 [json_name = "join_using_alias"];
  bool has_join_using_alias() const;
  void clear_join_using_alias() ;
  const ::pg_query::Alias& join_using_alias() const;
  PROTOBUF_NODISCARD ::pg_query::Alias* release_join_using_alias();
  ::pg_query::Alias* mutable_join_using_alias();
  void set_allocated_join_using_alias(::pg_query::Alias* value);
  void unsafe_arena_set_allocated_join_using_alias(::pg_query::Alias* value);
  ::pg_query::Alias* unsafe_arena_release_join_using_alias();

  private:
  const ::pg_query::Alias& _internal_join_using_alias() const;
  ::pg_query::Alias* _internal_mutable_join_using_alias();

  public:
  // .pg_query.Node quals = 7 [json_name = "quals"];
  bool has_quals() const;
  void clear_quals() ;
  const ::pg_query::Node& quals() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_quals();
  ::pg_query::Node* mutable_quals();
  void set_allocated_quals(::pg_query::Node* value);
  void unsafe_arena_set_allocated_quals(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_quals();

  private:
  const ::pg_query::Node& _internal_quals() const;
  ::pg_query::Node* _internal_mutable_quals();

  public:
  // .pg_query.Alias alias = 8 [json_name = "alias"];
  bool has_alias() const;
  void clear_alias() ;
  const ::pg_query::Alias& alias() const;
  PROTOBUF_NODISCARD ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* value);
  void unsafe_arena_set_allocated_alias(::pg_query::Alias* value);
  ::pg_query::Alias* unsafe_arena_release_alias();

  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();

  public:
  // .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 = 9 [json_name = "rtindex"];
  void clear_rtindex() ;
  ::int32_t rtindex() const;
  void set_rtindex(::int32_t value);

  private:
  ::int32_t _internal_rtindex() const;
  void _internal_set_rtindex(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.JoinExpr)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 9, 6,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > using_clause_;
    ::pg_query::Node* larg_;
    ::pg_query::Node* rarg_;
    ::pg_query::Alias* join_using_alias_;
    ::pg_query::Node* quals_;
    ::pg_query::Alias* alias_;
    int jointype_;
    bool is_natural_;
    ::int32_t rtindex_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonAggConstructor final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonAggConstructor) */ {
 public:
  inline JsonAggConstructor() : JsonAggConstructor(nullptr) {}
  ~JsonAggConstructor() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonAggConstructor(::google::protobuf::internal::ConstantInitialized);

  inline JsonAggConstructor(const JsonAggConstructor& from)
      : JsonAggConstructor(nullptr, from) {}
  JsonAggConstructor(JsonAggConstructor&& from) noexcept
    : JsonAggConstructor() {
    *this = ::std::move(from);
  }

  inline JsonAggConstructor& operator=(const JsonAggConstructor& from) {
    CopyFrom(from);
    return *this;
  }
  inline JsonAggConstructor& operator=(JsonAggConstructor&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonAggConstructor& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonAggConstructor* internal_default_instance() {
    return reinterpret_cast<const JsonAggConstructor*>(
               &_JsonAggConstructor_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    123;

  friend void swap(JsonAggConstructor& a, JsonAggConstructor& b) {
    a.Swap(&b);
  }
  inline void Swap(JsonAggConstructor* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JsonAggConstructor* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  JsonAggConstructor* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonAggConstructor>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonAggConstructor& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonAggConstructor& from) {
    JsonAggConstructor::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonAggConstructor* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonAggConstructor";
  }
  protected:
  explicit JsonAggConstructor(::google::protobuf::Arena* arena);
  JsonAggConstructor(::google::protobuf::Arena* arena, const JsonAggConstructor& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAggOrderFieldNumber = 3,
    kOutputFieldNumber = 1,
    kAggFilterFieldNumber = 2,
    kOverFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_agg_order();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_agg_order() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_agg_order();
  public:
  const ::pg_query::Node& agg_order(int index) const;
  ::pg_query::Node* add_agg_order();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      agg_order() const;
  // .pg_query.JsonOutput output = 1 [json_name = "output"];
  bool has_output() const;
  void clear_output() ;
  const ::pg_query::JsonOutput& output() const;
  PROTOBUF_NODISCARD ::pg_query::JsonOutput* release_output();
  ::pg_query::JsonOutput* mutable_output();
  void set_allocated_output(::pg_query::JsonOutput* value);
  void unsafe_arena_set_allocated_output(::pg_query::JsonOutput* value);
  ::pg_query::JsonOutput* unsafe_arena_release_output();

  private:
  const ::pg_query::JsonOutput& _internal_output() const;
  ::pg_query::JsonOutput* _internal_mutable_output();

  public:
  // .pg_query.Node agg_filter = 2 [json_name = "agg_filter"];
  bool has_agg_filter() const;
  void clear_agg_filter() ;
  const ::pg_query::Node& agg_filter() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_agg_filter();
  ::pg_query::Node* mutable_agg_filter();
  void set_allocated_agg_filter(::pg_query::Node* value);
  void unsafe_arena_set_allocated_agg_filter(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_agg_filter();

  private:
  const ::pg_query::Node& _internal_agg_filter() const;
  ::pg_query::Node* _internal_mutable_agg_filter();

  public:
  // .pg_query.WindowDef over = 4 [json_name = "over"];
  bool has_over() const;
  void clear_over() ;
  const ::pg_query::WindowDef& over() const;
  PROTOBUF_NODISCARD ::pg_query::WindowDef* release_over();
  ::pg_query::WindowDef* mutable_over();
  void set_allocated_over(::pg_query::WindowDef* value);
  void unsafe_arena_set_allocated_over(::pg_query::WindowDef* value);
  ::pg_query::WindowDef* unsafe_arena_release_over();

  private:
  const ::pg_query::WindowDef& _internal_over() const;
  ::pg_query::WindowDef* _internal_mutable_over();

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.JsonAggConstructor)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 4,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > agg_order_;
    ::pg_query::JsonOutput* output_;
    ::pg_query::Node* agg_filter_;
    ::pg_query::WindowDef* over_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonArrayAgg final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonArrayAgg) */ {
 public:
  inline JsonArrayAgg() : JsonArrayAgg(nullptr) {}
  ~JsonArrayAgg() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonArrayAgg(::google::protobuf::internal::ConstantInitialized);

  inline JsonArrayAgg(const JsonArrayAgg& from)
      : JsonArrayAgg(nullptr, from) {}
  JsonArrayAgg(JsonArrayAgg&& from) noexcept
    : JsonArrayAgg() {
    *this = ::std::move(from);
  }

  inline JsonArrayAgg& operator=(const JsonArrayAgg& from) {
    CopyFrom(from);
    return *this;
  }
  inline JsonArrayAgg& operator=(JsonArrayAgg&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonArrayAgg& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonArrayAgg* internal_default_instance() {
    return reinterpret_cast<const JsonArrayAgg*>(
               &_JsonArrayAgg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    125;

  friend void swap(JsonArrayAgg& a, JsonArrayAgg& b) {
    a.Swap(&b);
  }
  inline void Swap(JsonArrayAgg* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JsonArrayAgg* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  JsonArrayAgg* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonArrayAgg>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonArrayAgg& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonArrayAgg& from) {
    JsonArrayAgg::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonArrayAgg* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonArrayAgg";
  }
  protected:
  explicit JsonArrayAgg(::google::protobuf::Arena* arena);
  JsonArrayAgg(::google::protobuf::Arena* arena, const JsonArrayAgg& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kConstructorFieldNumber = 1,
    kArgFieldNumber = 2,
    kAbsentOnNullFieldNumber = 3,
  };
  // .pg_query.JsonAggConstructor constructor = 1 [json_name = "constructor"];
  bool has_constructor() const;
  void clear_constructor() ;
  const ::pg_query::JsonAggConstructor& constructor() const;
  PROTOBUF_NODISCARD ::pg_query::JsonAggConstructor* release_constructor();
  ::pg_query::JsonAggConstructor* mutable_constructor();
  void set_allocated_constructor(::pg_query::JsonAggConstructor* value);
  void unsafe_arena_set_allocated_constructor(::pg_query::JsonAggConstructor* value);
  ::pg_query::JsonAggConstructor* unsafe_arena_release_constructor();

  private:
  const ::pg_query::JsonAggConstructor& _internal_constructor() const;
  ::pg_query::JsonAggConstructor* _internal_mutable_constructor();

  public:
  // .pg_query.JsonValueExpr arg = 2 [json_name = "arg"];
  bool has_arg() const;
  void clear_arg() ;
  const ::pg_query::JsonValueExpr& arg() const;
  PROTOBUF_NODISCARD ::pg_query::JsonValueExpr* release_arg();
  ::pg_query::JsonValueExpr* mutable_arg();
  void set_allocated_arg(::pg_query::JsonValueExpr* value);
  void unsafe_arena_set_allocated_arg(::pg_query::JsonValueExpr* value);
  ::pg_query::JsonValueExpr* unsafe_arena_release_arg();

  private:
  const ::pg_query::JsonValueExpr& _internal_arg() const;
  ::pg_query::JsonValueExpr* _internal_mutable_arg();

  public:
  // bool absent_on_null = 3 [json_name = "absent_on_null"];
  void clear_absent_on_null() ;
  bool absent_on_null() const;
  void set_absent_on_null(bool value);

  private:
  bool _internal_absent_on_null() const;
  void _internal_set_absent_on_null(bool value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.JsonArrayAgg)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::JsonAggConstructor* constructor_;
    ::pg_query::JsonValueExpr* arg_;
    bool absent_on_null_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonArrayConstructor final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonArrayConstructor) */ {
 public:
  inline JsonArrayConstructor() : JsonArrayConstructor(nullptr) {}
  ~JsonArrayConstructor() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonArrayConstructor(::google::protobuf::internal::ConstantInitialized);

  inline JsonArrayConstructor(const JsonArrayConstructor& from)
      : JsonArrayConstructor(nullptr, from) {}
  JsonArrayConstructor(JsonArrayConstructor&& from) noexcept
    : JsonArrayConstructor() {
    *this = ::std::move(from);
  }

  inline JsonArrayConstructor& operator=(const JsonArrayConstructor& from) {
    CopyFrom(from);
    return *this;
  }
  inline JsonArrayConstructor& operator=(JsonArrayConstructor&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonArrayConstructor& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonArrayConstructor* internal_default_instance() {
    return reinterpret_cast<const JsonArrayConstructor*>(
               &_JsonArrayConstructor_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    121;

  friend void swap(JsonArrayConstructor& a, JsonArrayConstructor& b) {
    a.Swap(&b);
  }
  inline void Swap(JsonArrayConstructor* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JsonArrayConstructor* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  JsonArrayConstructor* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonArrayConstructor>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonArrayConstructor& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonArrayConstructor& from) {
    JsonArrayConstructor::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonArrayConstructor* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonArrayConstructor";
  }
  protected:
  explicit JsonArrayConstructor(::google::protobuf::Arena* arena);
  JsonArrayConstructor(::google::protobuf::Arena* arena, const JsonArrayConstructor& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kExprsFieldNumber = 1,
    kOutputFieldNumber = 2,
    kAbsentOnNullFieldNumber = 3,
    kLocationFieldNumber = 4,
  };
  // repeated .pg_query.Node exprs = 1 [json_name = "exprs"];
  int exprs_size() const;
  private:
  int _internal_exprs_size() const;

  public:
  void clear_exprs() ;
  ::pg_query::Node* mutable_exprs(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_exprs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_exprs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_exprs();
  public:
  const ::pg_query::Node& exprs(int index) const;
  ::pg_query::Node* add_exprs();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      exprs() const;
  // .pg_query.JsonOutput output = 2 [json_name = "output"];
  bool has_output() const;
  void clear_output() ;
  const ::pg_query::JsonOutput& output() const;
  PROTOBUF_NODISCARD ::pg_query::JsonOutput* release_output();
  ::pg_query::JsonOutput* mutable_output();
  void set_allocated_output(::pg_query::JsonOutput* value);
  void unsafe_arena_set_allocated_output(::pg_query::JsonOutput* value);
  ::pg_query::JsonOutput* unsafe_arena_release_output();

  private:
  const ::pg_query::JsonOutput& _internal_output() const;
  ::pg_query::JsonOutput* _internal_mutable_output();

  public:
  // bool absent_on_null = 3 [json_name = "absent_on_null"];
  void clear_absent_on_null() ;
  bool absent_on_null() const;
  void set_absent_on_null(bool value);

  private:
  bool _internal_absent_on_null() const;
  void _internal_set_absent_on_null(bool value);

  public:
  // int32 location = 4 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.JsonArrayConstructor)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > exprs_;
    ::pg_query::JsonOutput* output_;
    bool absent_on_null_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonArrayQueryConstructor final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonArrayQueryConstructor) */ {
 public:
  inline JsonArrayQueryConstructor() : JsonArrayQueryConstructor(nullptr) {}
  ~JsonArrayQueryConstructor() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonArrayQueryConstructor(::google::protobuf::internal::ConstantInitialized);

  inline JsonArrayQueryConstructor(const JsonArrayQueryConstructor& from)
      : JsonArrayQueryConstructor(nullptr, from) {}
  JsonArrayQueryConstructor(JsonArrayQueryConstructor&& from) noexcept
    : JsonArrayQueryConstructor() {
    *this = ::std::move(from);
  }

  inline JsonArrayQueryConstructor& operator=(const JsonArrayQueryConstructor& from) {
    CopyFrom(from);
    return *this;
  }
  inline JsonArrayQueryConstructor& operator=(JsonArrayQueryConstructor&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonArrayQueryConstructor& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonArrayQueryConstructor* internal_default_instance() {
    return reinterpret_cast<const JsonArrayQueryConstructor*>(
               &_JsonArrayQueryConstructor_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    122;

  friend void swap(JsonArrayQueryConstructor& a, JsonArrayQueryConstructor& b) {
    a.Swap(&b);
  }
  inline void Swap(JsonArrayQueryConstructor* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JsonArrayQueryConstructor* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  JsonArrayQueryConstructor* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonArrayQueryConstructor>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonArrayQueryConstructor& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonArrayQueryConstructor& from) {
    JsonArrayQueryConstructor::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonArrayQueryConstructor* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonArrayQueryConstructor";
  }
  protected:
  explicit JsonArrayQueryConstructor(::google::protobuf::Arena* arena);
  JsonArrayQueryConstructor(::google::protobuf::Arena* arena, const JsonArrayQueryConstructor& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kQueryFieldNumber = 1,
    kOutputFieldNumber = 2,
    kFormatFieldNumber = 3,
    kAbsentOnNullFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // .pg_query.Node query = 1 [json_name = "query"];
  bool has_query() const;
  void clear_query() ;
  const ::pg_query::Node& query() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* value);
  void unsafe_arena_set_allocated_query(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_query();

  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();

  public:
  // .pg_query.JsonOutput output = 2 [json_name = "output"];
  bool has_output() const;
  void clear_output() ;
  const ::pg_query::JsonOutput& output() const;
  PROTOBUF_NODISCARD ::pg_query::JsonOutput* release_output();
  ::pg_query::JsonOutput* mutable_output();
  void set_allocated_output(::pg_query::JsonOutput* value);
  void unsafe_arena_set_allocated_output(::pg_query::JsonOutput* value);
  ::pg_query::JsonOutput* unsafe_arena_release_output();

  private:
  const ::pg_query::JsonOutput& _internal_output() const;
  ::pg_query::JsonOutput* _internal_mutable_output();

  public:
  // .pg_query.JsonFormat format = 3 [json_name = "format"];
  bool has_format() const;
  void clear_format() ;
  const ::pg_query::JsonFormat& format() const;
  PROTOBUF_NODISCARD ::pg_query::JsonFormat* release_format();
  ::pg_query::JsonFormat* mutable_format();
  void set_allocated_format(::pg_query::JsonFormat* value);
  void unsafe_arena_set_allocated_format(::pg_query::JsonFormat* value);
  ::pg_query::JsonFormat* unsafe_arena_release_format();

  private:
  const ::pg_query::JsonFormat& _internal_format() const;
  ::pg_query::JsonFormat* _internal_mutable_format();

  public:
  // bool absent_on_null = 4 [json_name = "absent_on_null"];
  void clear_absent_on_null() ;
  bool absent_on_null() const;
  void set_absent_on_null(bool value);

  private:
  bool _internal_absent_on_null() const;
  void _internal_set_absent_on_null(bool value);

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.JsonArrayQueryConstructor)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* query_;
    ::pg_query::JsonOutput* output_;
    ::pg_query::JsonFormat* format_;
    bool absent_on_null_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonConstructorExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonConstructorExpr) */ {
 public:
  inline JsonConstructorExpr() : JsonConstructorExpr(nullptr) {}
  ~JsonConstructorExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonConstructorExpr(::google::protobuf::internal::ConstantInitialized);

  inline JsonConstructorExpr(const JsonConstructorExpr& from)
      : JsonConstructorExpr(nullptr, from) {}
  JsonConstructorExpr(JsonConstructorExpr&& from) noexcept
    : JsonConstructorExpr() {
    *this = ::std::move(from);
  }

  inline JsonConstructorExpr& operator=(const JsonConstructorExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline JsonConstructorExpr& operator=(JsonConstructorExpr&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonConstructorExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonConstructorExpr* internal_default_instance() {
    return reinterpret_cast<const JsonConstructorExpr*>(
               &_JsonConstructorExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    52;

  friend void swap(JsonConstructorExpr& a, JsonConstructorExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(JsonConstructorExpr* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JsonConstructorExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  JsonConstructorExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonConstructorExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonConstructorExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonConstructorExpr& from) {
    JsonConstructorExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonConstructorExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonConstructorExpr";
  }
  protected:
  explicit JsonConstructorExpr(::google::protobuf::Arena* arena);
  JsonConstructorExpr(::google::protobuf::Arena* arena, const JsonConstructorExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kArgsFieldNumber = 3,
    kXprFieldNumber = 1,
    kFuncFieldNumber = 4,
    kCoercionFieldNumber = 5,
    kReturningFieldNumber = 6,
    kTypeFieldNumber = 2,
    kAbsentOnNullFieldNumber = 7,
    kUniqueFieldNumber = 8,
    kLocationFieldNumber = 9,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node func = 4 [json_name = "func"];
  bool has_func() const;
  void clear_func() ;
  const ::pg_query::Node& func() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_func();
  ::pg_query::Node* mutable_func();
  void set_allocated_func(::pg_query::Node* value);
  void unsafe_arena_set_allocated_func(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_func();

  private:
  const ::pg_query::Node& _internal_func() const;
  ::pg_query::Node* _internal_mutable_func();

  public:
  // .pg_query.Node coercion = 5 [json_name = "coercion"];
  bool has_coercion() const;
  void clear_coercion() ;
  const ::pg_query::Node& coercion() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_coercion();
  ::pg_query::Node* mutable_coercion();
  void set_allocated_coercion(::pg_query::Node* value);
  void unsafe_arena_set_allocated_coercion(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_coercion();

  private:
  const ::pg_query::Node& _internal_coercion() const;
  ::pg_query::Node* _internal_mutable_coercion();

  public:
  // .pg_query.JsonReturning returning = 6 [json_name = "returning"];
  bool has_returning() const;
  void clear_returning() ;
  const ::pg_query::JsonReturning& returning() const;
  PROTOBUF_NODISCARD ::pg_query::JsonReturning* release_returning();
  ::pg_query::JsonReturning* mutable_returning();
  void set_allocated_returning(::pg_query::JsonReturning* value);
  void unsafe_arena_set_allocated_returning(::pg_query::JsonReturning* value);
  ::pg_query::JsonReturning* unsafe_arena_release_returning();

  private:
  const ::pg_query::JsonReturning& _internal_returning() const;
  ::pg_query::JsonReturning* _internal_mutable_returning();

  public:
  // .pg_query.JsonConstructorType type = 2 [json_name = "type"];
  void clear_type() ;
  ::pg_query::JsonConstructorType type() const;
  void set_type(::pg_query::JsonConstructorType value);

  private:
  ::pg_query::JsonConstructorType _internal_type() const;
  void _internal_set_type(::pg_query::JsonConstructorType value);

  public:
  // bool absent_on_null = 7 [json_name = "absent_on_null"];
  void clear_absent_on_null() ;
  bool absent_on_null() const;
  void set_absent_on_null(bool value);

  private:
  bool _internal_absent_on_null() const;
  void _internal_set_absent_on_null(bool value);

  public:
  // bool unique = 8 [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:
  // int32 location = 9 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.JsonConstructorExpr)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 9, 5,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* func_;
    ::pg_query::Node* coercion_;
    ::pg_query::JsonReturning* returning_;
    int type_;
    bool absent_on_null_;
    bool unique_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonIsPredicate final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonIsPredicate) */ {
 public:
  inline JsonIsPredicate() : JsonIsPredicate(nullptr) {}
  ~JsonIsPredicate() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonIsPredicate(::google::protobuf::internal::ConstantInitialized);

  inline JsonIsPredicate(const JsonIsPredicate& from)
      : JsonIsPredicate(nullptr, from) {}
  JsonIsPredicate(JsonIsPredicate&& from) noexcept
    : JsonIsPredicate() {
    *this = ::std::move(from);
  }

  inline JsonIsPredicate& operator=(const JsonIsPredicate& from) {
    CopyFrom(from);
    return *this;
  }
  inline JsonIsPredicate& operator=(JsonIsPredicate&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonIsPredicate& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonIsPredicate* internal_default_instance() {
    return reinterpret_cast<const JsonIsPredicate*>(
               &_JsonIsPredicate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    53;

  friend void swap(JsonIsPredicate& a, JsonIsPredicate& b) {
    a.Swap(&b);
  }
  inline void Swap(JsonIsPredicate* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JsonIsPredicate* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  JsonIsPredicate* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonIsPredicate>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonIsPredicate& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonIsPredicate& from) {
    JsonIsPredicate::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonIsPredicate* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonIsPredicate";
  }
  protected:
  explicit JsonIsPredicate(::google::protobuf::Arena* arena);
  JsonIsPredicate(::google::protobuf::Arena* arena, const JsonIsPredicate& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kExprFieldNumber = 1,
    kFormatFieldNumber = 2,
    kItemTypeFieldNumber = 3,
    kUniqueKeysFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // .pg_query.Node expr = 1 [json_name = "expr"];
  bool has_expr() const;
  void clear_expr() ;
  const ::pg_query::Node& expr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_expr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_expr();

  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();

  public:
  // .pg_query.JsonFormat format = 2 [json_name = "format"];
  bool has_format() const;
  void clear_format() ;
  const ::pg_query::JsonFormat& format() const;
  PROTOBUF_NODISCARD ::pg_query::JsonFormat* release_format();
  ::pg_query::JsonFormat* mutable_format();
  void set_allocated_format(::pg_query::JsonFormat* value);
  void unsafe_arena_set_allocated_format(::pg_query::JsonFormat* value);
  ::pg_query::JsonFormat* unsafe_arena_release_format();

  private:
  const ::pg_query::JsonFormat& _internal_format() const;
  ::pg_query::JsonFormat* _internal_mutable_format();

  public:
  // .pg_query.JsonValueType item_type = 3 [json_name = "item_type"];
  void clear_item_type() ;
  ::pg_query::JsonValueType item_type() const;
  void set_item_type(::pg_query::JsonValueType value);

  private:
  ::pg_query::JsonValueType _internal_item_type() const;
  void _internal_set_item_type(::pg_query::JsonValueType value);

  public:
  // bool unique_keys = 4 [json_name = "unique_keys"];
  void clear_unique_keys() ;
  bool unique_keys() const;
  void set_unique_keys(bool value);

  private:
  bool _internal_unique_keys() const;
  void _internal_set_unique_keys(bool value);

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.JsonIsPredicate)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* expr_;
    ::pg_query::JsonFormat* format_;
    int item_type_;
    bool unique_keys_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonKeyValue final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonKeyValue) */ {
 public:
  inline JsonKeyValue() : JsonKeyValue(nullptr) {}
  ~JsonKeyValue() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonKeyValue(::google::protobuf::internal::ConstantInitialized);

  inline JsonKeyValue(const JsonKeyValue& from)
      : JsonKeyValue(nullptr, from) {}
  JsonKeyValue(JsonKeyValue&& from) noexcept
    : JsonKeyValue() {
    *this = ::std::move(from);
  }

  inline JsonKeyValue& operator=(const JsonKeyValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline JsonKeyValue& operator=(JsonKeyValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonKeyValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonKeyValue* internal_default_instance() {
    return reinterpret_cast<const JsonKeyValue*>(
               &_JsonKeyValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    119;

  friend void swap(JsonKeyValue& a, JsonKeyValue& b) {
    a.Swap(&b);
  }
  inline void Swap(JsonKeyValue* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JsonKeyValue* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  JsonKeyValue* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonKeyValue>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonKeyValue& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonKeyValue& from) {
    JsonKeyValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonKeyValue* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonKeyValue";
  }
  protected:
  explicit JsonKeyValue(::google::protobuf::Arena* arena);
  JsonKeyValue(::google::protobuf::Arena* arena, const JsonKeyValue& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // .pg_query.Node key = 1 [json_name = "key"];
  bool has_key() const;
  void clear_key() ;
  const ::pg_query::Node& key() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_key();
  ::pg_query::Node* mutable_key();
  void set_allocated_key(::pg_query::Node* value);
  void unsafe_arena_set_allocated_key(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_key();

  private:
  const ::pg_query::Node& _internal_key() const;
  ::pg_query::Node* _internal_mutable_key();

  public:
  // .pg_query.JsonValueExpr value = 2 [json_name = "value"];
  bool has_value() const;
  void clear_value() ;
  const ::pg_query::JsonValueExpr& value() const;
  PROTOBUF_NODISCARD ::pg_query::JsonValueExpr* release_value();
  ::pg_query::JsonValueExpr* mutable_value();
  void set_allocated_value(::pg_query::JsonValueExpr* value);
  void unsafe_arena_set_allocated_value(::pg_query::JsonValueExpr* value);
  ::pg_query::JsonValueExpr* unsafe_arena_release_value();

  private:
  const ::pg_query::JsonValueExpr& _internal_value() const;
  ::pg_query::JsonValueExpr* _internal_mutable_value();

  public:
  // @@protoc_insertion_point(class_scope:pg_query.JsonKeyValue)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* key_;
    ::pg_query::JsonValueExpr* value_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonObjectAgg final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonObjectAgg) */ {
 public:
  inline JsonObjectAgg() : JsonObjectAgg(nullptr) {}
  ~JsonObjectAgg() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonObjectAgg(::google::protobuf::internal::ConstantInitialized);

  inline JsonObjectAgg(const JsonObjectAgg& from)
      : JsonObjectAgg(nullptr, from) {}
  JsonObjectAgg(JsonObjectAgg&& from) noexcept
    : JsonObjectAgg() {
    *this = ::std::move(from);
  }

  inline JsonObjectAgg& operator=(const JsonObjectAgg& from) {
    CopyFrom(from);
    return *this;
  }
  inline JsonObjectAgg& operator=(JsonObjectAgg&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonObjectAgg& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonObjectAgg* internal_default_instance() {
    return reinterpret_cast<const JsonObjectAgg*>(
               &_JsonObjectAgg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    124;

  friend void swap(JsonObjectAgg& a, JsonObjectAgg& b) {
    a.Swap(&b);
  }
  inline void Swap(JsonObjectAgg* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JsonObjectAgg* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  JsonObjectAgg* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonObjectAgg>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonObjectAgg& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonObjectAgg& from) {
    JsonObjectAgg::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonObjectAgg* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonObjectAgg";
  }
  protected:
  explicit JsonObjectAgg(::google::protobuf::Arena* arena);
  JsonObjectAgg(::google::protobuf::Arena* arena, const JsonObjectAgg& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kConstructorFieldNumber = 1,
    kArgFieldNumber = 2,
    kAbsentOnNullFieldNumber = 3,
    kUniqueFieldNumber = 4,
  };
  // .pg_query.JsonAggConstructor constructor = 1 [json_name = "constructor"];
  bool has_constructor() const;
  void clear_constructor() ;
  const ::pg_query::JsonAggConstructor& constructor() const;
  PROTOBUF_NODISCARD ::pg_query::JsonAggConstructor* release_constructor();
  ::pg_query::JsonAggConstructor* mutable_constructor();
  void set_allocated_constructor(::pg_query::JsonAggConstructor* value);
  void unsafe_arena_set_allocated_constructor(::pg_query::JsonAggConstructor* value);
  ::pg_query::JsonAggConstructor* unsafe_arena_release_constructor();

  private:
  const ::pg_query::JsonAggConstructor& _internal_constructor() const;
  ::pg_query::JsonAggConstructor* _internal_mutable_constructor();

  public:
  // .pg_query.JsonKeyValue arg = 2 [json_name = "arg"];
  bool has_arg() const;
  void clear_arg() ;
  const ::pg_query::JsonKeyValue& arg() const;
  PROTOBUF_NODISCARD ::pg_query::JsonKeyValue* release_arg();
  ::pg_query::JsonKeyValue* mutable_arg();
  void set_allocated_arg(::pg_query::JsonKeyValue* value);
  void unsafe_arena_set_allocated_arg(::pg_query::JsonKeyValue* value);
  ::pg_query::JsonKeyValue* unsafe_arena_release_arg();

  private:
  const ::pg_query::JsonKeyValue& _internal_arg() const;
  ::pg_query::JsonKeyValue* _internal_mutable_arg();

  public:
  // bool absent_on_null = 3 [json_name = "absent_on_null"];
  void clear_absent_on_null() ;
  bool absent_on_null() const;
  void set_absent_on_null(bool value);

  private:
  bool _internal_absent_on_null() const;
  void _internal_set_absent_on_null(bool value);

  public:
  // bool unique = 4 [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:
  // @@protoc_insertion_point(class_scope:pg_query.JsonObjectAgg)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::JsonAggConstructor* constructor_;
    ::pg_query::JsonKeyValue* arg_;
    bool absent_on_null_;
    bool unique_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonObjectConstructor final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonObjectConstructor) */ {
 public:
  inline JsonObjectConstructor() : JsonObjectConstructor(nullptr) {}
  ~JsonObjectConstructor() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonObjectConstructor(::google::protobuf::internal::ConstantInitialized);

  inline JsonObjectConstructor(const JsonObjectConstructor& from)
      : JsonObjectConstructor(nullptr, from) {}
  JsonObjectConstructor(JsonObjectConstructor&& from) noexcept
    : JsonObjectConstructor() {
    *this = ::std::move(from);
  }

  inline JsonObjectConstructor& operator=(const JsonObjectConstructor& from) {
    CopyFrom(from);
    return *this;
  }
  inline JsonObjectConstructor& operator=(JsonObjectConstructor&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonObjectConstructor& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonObjectConstructor* internal_default_instance() {
    return reinterpret_cast<const JsonObjectConstructor*>(
               &_JsonObjectConstructor_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    120;

  friend void swap(JsonObjectConstructor& a, JsonObjectConstructor& b) {
    a.Swap(&b);
  }
  inline void Swap(JsonObjectConstructor* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JsonObjectConstructor* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  JsonObjectConstructor* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonObjectConstructor>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonObjectConstructor& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonObjectConstructor& from) {
    JsonObjectConstructor::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonObjectConstructor* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonObjectConstructor";
  }
  protected:
  explicit JsonObjectConstructor(::google::protobuf::Arena* arena);
  JsonObjectConstructor(::google::protobuf::Arena* arena, const JsonObjectConstructor& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kExprsFieldNumber = 1,
    kOutputFieldNumber = 2,
    kAbsentOnNullFieldNumber = 3,
    kUniqueFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // repeated .pg_query.Node exprs = 1 [json_name = "exprs"];
  int exprs_size() const;
  private:
  int _internal_exprs_size() const;

  public:
  void clear_exprs() ;
  ::pg_query::Node* mutable_exprs(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_exprs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_exprs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_exprs();
  public:
  const ::pg_query::Node& exprs(int index) const;
  ::pg_query::Node* add_exprs();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      exprs() const;
  // .pg_query.JsonOutput output = 2 [json_name = "output"];
  bool has_output() const;
  void clear_output() ;
  const ::pg_query::JsonOutput& output() const;
  PROTOBUF_NODISCARD ::pg_query::JsonOutput* release_output();
  ::pg_query::JsonOutput* mutable_output();
  void set_allocated_output(::pg_query::JsonOutput* value);
  void unsafe_arena_set_allocated_output(::pg_query::JsonOutput* value);
  ::pg_query::JsonOutput* unsafe_arena_release_output();

  private:
  const ::pg_query::JsonOutput& _internal_output() const;
  ::pg_query::JsonOutput* _internal_mutable_output();

  public:
  // bool absent_on_null = 3 [json_name = "absent_on_null"];
  void clear_absent_on_null() ;
  bool absent_on_null() const;
  void set_absent_on_null(bool value);

  private:
  bool _internal_absent_on_null() const;
  void _internal_set_absent_on_null(bool value);

  public:
  // bool unique = 4 [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:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.JsonObjectConstructor)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > exprs_;
    ::pg_query::JsonOutput* output_;
    bool absent_on_null_;
    bool unique_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonOutput final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonOutput) */ {
 public:
  inline JsonOutput() : JsonOutput(nullptr) {}
  ~JsonOutput() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonOutput(::google::protobuf::internal::ConstantInitialized);

  inline JsonOutput(const JsonOutput& from)
      : JsonOutput(nullptr, from) {}
  JsonOutput(JsonOutput&& from) noexcept
    : JsonOutput() {
    *this = ::std::move(from);
  }

  inline JsonOutput& operator=(const JsonOutput& from) {
    CopyFrom(from);
    return *this;
  }
  inline JsonOutput& operator=(JsonOutput&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonOutput& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonOutput* internal_default_instance() {
    return reinterpret_cast<const JsonOutput*>(
               &_JsonOutput_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    118;

  friend void swap(JsonOutput& a, JsonOutput& b) {
    a.Swap(&b);
  }
  inline void Swap(JsonOutput* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JsonOutput* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  JsonOutput* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonOutput>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonOutput& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonOutput& from) {
    JsonOutput::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonOutput* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonOutput";
  }
  protected:
  explicit JsonOutput(::google::protobuf::Arena* arena);
  JsonOutput(::google::protobuf::Arena* arena, const JsonOutput& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTypeNameFieldNumber = 1,
    kReturningFieldNumber = 2,
  };
  // .pg_query.TypeName type_name = 1 [json_name = "typeName"];
  bool has_type_name() const;
  void clear_type_name() ;
  const ::pg_query::TypeName& type_name() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_type_name(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();

  public:
  // .pg_query.JsonReturning returning = 2 [json_name = "returning"];
  bool has_returning() const;
  void clear_returning() ;
  const ::pg_query::JsonReturning& returning() const;
  PROTOBUF_NODISCARD ::pg_query::JsonReturning* release_returning();
  ::pg_query::JsonReturning* mutable_returning();
  void set_allocated_returning(::pg_query::JsonReturning* value);
  void unsafe_arena_set_allocated_returning(::pg_query::JsonReturning* value);
  ::pg_query::JsonReturning* unsafe_arena_release_returning();

  private:
  const ::pg_query::JsonReturning& _internal_returning() const;
  ::pg_query::JsonReturning* _internal_mutable_returning();

  public:
  // @@protoc_insertion_point(class_scope:pg_query.JsonOutput)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::TypeName* type_name_;
    ::pg_query::JsonReturning* returning_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class JsonValueExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.JsonValueExpr) */ {
 public:
  inline JsonValueExpr() : JsonValueExpr(nullptr) {}
  ~JsonValueExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR JsonValueExpr(::google::protobuf::internal::ConstantInitialized);

  inline JsonValueExpr(const JsonValueExpr& from)
      : JsonValueExpr(nullptr, from) {}
  JsonValueExpr(JsonValueExpr&& from) noexcept
    : JsonValueExpr() {
    *this = ::std::move(from);
  }

  inline JsonValueExpr& operator=(const JsonValueExpr& from) {
    CopyFrom(from);
    return *this;
  }
  inline JsonValueExpr& operator=(JsonValueExpr&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const JsonValueExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonValueExpr* internal_default_instance() {
    return reinterpret_cast<const JsonValueExpr*>(
               &_JsonValueExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    51;

  friend void swap(JsonValueExpr& a, JsonValueExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(JsonValueExpr* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(JsonValueExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  JsonValueExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonValueExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const JsonValueExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const JsonValueExpr& from) {
    JsonValueExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(JsonValueExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.JsonValueExpr";
  }
  protected:
  explicit JsonValueExpr(::google::protobuf::Arena* arena);
  JsonValueExpr(::google::protobuf::Arena* arena, const JsonValueExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRawExprFieldNumber = 1,
    kFormattedExprFieldNumber = 2,
    kFormatFieldNumber = 3,
  };
  // .pg_query.Node raw_expr = 1 [json_name = "raw_expr"];
  bool has_raw_expr() const;
  void clear_raw_expr() ;
  const ::pg_query::Node& raw_expr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_raw_expr();
  ::pg_query::Node* mutable_raw_expr();
  void set_allocated_raw_expr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_raw_expr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_raw_expr();

  private:
  const ::pg_query::Node& _internal_raw_expr() const;
  ::pg_query::Node* _internal_mutable_raw_expr();

  public:
  // .pg_query.Node formatted_expr = 2 [json_name = "formatted_expr"];
  bool has_formatted_expr() const;
  void clear_formatted_expr() ;
  const ::pg_query::Node& formatted_expr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_formatted_expr();
  ::pg_query::Node* mutable_formatted_expr();
  void set_allocated_formatted_expr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_formatted_expr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_formatted_expr();

  private:
  const ::pg_query::Node& _internal_formatted_expr() const;
  ::pg_query::Node* _internal_mutable_formatted_expr();

  public:
  // .pg_query.JsonFormat format = 3 [json_name = "format"];
  bool has_format() const;
  void clear_format() ;
  const ::pg_query::JsonFormat& format() const;
  PROTOBUF_NODISCARD ::pg_query::JsonFormat* release_format();
  ::pg_query::JsonFormat* mutable_format();
  void set_allocated_format(::pg_query::JsonFormat* value);
  void unsafe_arena_set_allocated_format(::pg_query::JsonFormat* value);
  ::pg_query::JsonFormat* unsafe_arena_release_format();

  private:
  const ::pg_query::JsonFormat& _internal_format() const;
  ::pg_query::JsonFormat* _internal_mutable_format();

  public:
  // @@protoc_insertion_point(class_scope:pg_query.JsonValueExpr)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* raw_expr_;
    ::pg_query::Node* formatted_expr_;
    ::pg_query::JsonFormat* format_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class List final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.List) */ {
 public:
  inline List() : List(nullptr) {}
  ~List() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR List(::google::protobuf::internal::ConstantInitialized);

  inline List(const List& from)
      : List(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const List& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(List* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  List* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<List>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const List& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const List& from) {
    List::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(List* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.List";
  }
  protected:
  explicit List(::google::protobuf::Arena* arena);
  List(::google::protobuf::Arena* arena, const List& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_items();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_items() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_items();
  public:
  const ::pg_query::Node& items(int index) const;
  ::pg_query::Node* add_items();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      items() const;
  // @@protoc_insertion_point(class_scope:pg_query.List)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > items_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class LockStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.LockStmt) */ {
 public:
  inline LockStmt() : LockStmt(nullptr) {}
  ~LockStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR LockStmt(::google::protobuf::internal::ConstantInitialized);

  inline LockStmt(const LockStmt& from)
      : LockStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LockStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const LockStmt* internal_default_instance() {
    return reinterpret_cast<const LockStmt*>(
               &_LockStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    235;

  friend void swap(LockStmt& a, LockStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(LockStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LockStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  LockStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LockStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const LockStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const LockStmt& from) {
    LockStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(LockStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.LockStmt";
  }
  protected:
  explicit LockStmt(::google::protobuf::Arena* arena);
  LockStmt(::google::protobuf::Arena* arena, const LockStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_relations();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_relations() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_relations();
  public:
  const ::pg_query::Node& relations(int index) const;
  ::pg_query::Node* add_relations();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      relations() const;
  // int32 mode = 2 [json_name = "mode"];
  void clear_mode() ;
  ::int32_t mode() const;
  void set_mode(::int32_t value);

  private:
  ::int32_t _internal_mode() const;
  void _internal_set_mode(::int32_t 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > relations_;
    ::int32_t mode_;
    bool nowait_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class LockingClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.LockingClause) */ {
 public:
  inline LockingClause() : LockingClause(nullptr) {}
  ~LockingClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR LockingClause(::google::protobuf::internal::ConstantInitialized);

  inline LockingClause(const LockingClause& from)
      : LockingClause(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LockingClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const LockingClause* internal_default_instance() {
    return reinterpret_cast<const LockingClause*>(
               &_LockingClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    93;

  friend void swap(LockingClause& a, LockingClause& b) {
    a.Swap(&b);
  }
  inline void Swap(LockingClause* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LockingClause* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  LockingClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LockingClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const LockingClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const LockingClause& from) {
    LockingClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(LockingClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.LockingClause";
  }
  protected:
  explicit LockingClause(::google::protobuf::Arena* arena);
  LockingClause(::google::protobuf::Arena* arena, const LockingClause& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_locked_rels();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_locked_rels() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_locked_rels();
  public:
  const ::pg_query::Node& locked_rels(int index) const;
  ::pg_query::Node* add_locked_rels();
  const ::google::protobuf::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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > locked_rels_;
    int strength_;
    int wait_policy_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class MergeAction final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.MergeAction) */ {
 public:
  inline MergeAction() : MergeAction(nullptr) {}
  ~MergeAction() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR MergeAction(::google::protobuf::internal::ConstantInitialized);

  inline MergeAction(const MergeAction& from)
      : MergeAction(nullptr, from) {}
  MergeAction(MergeAction&& from) noexcept
    : MergeAction() {
    *this = ::std::move(from);
  }

  inline MergeAction& operator=(const MergeAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline MergeAction& operator=(MergeAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MergeAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const MergeAction* internal_default_instance() {
    return reinterpret_cast<const MergeAction*>(
               &_MergeAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    116;

  friend void swap(MergeAction& a, MergeAction& b) {
    a.Swap(&b);
  }
  inline void Swap(MergeAction* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MergeAction* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MergeAction* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MergeAction>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const MergeAction& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const MergeAction& from) {
    MergeAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(MergeAction* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.MergeAction";
  }
  protected:
  explicit MergeAction(::google::protobuf::Arena* arena);
  MergeAction(::google::protobuf::Arena* arena, const MergeAction& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTargetListFieldNumber = 5,
    kUpdateColnosFieldNumber = 6,
    kQualFieldNumber = 4,
    kMatchedFieldNumber = 1,
    kCommandTypeFieldNumber = 2,
    kOverrideFieldNumber = 3,
  };
  // repeated .pg_query.Node target_list = 5 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_target_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_target_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_target_list();
  public:
  const ::pg_query::Node& target_list(int index) const;
  ::pg_query::Node* add_target_list();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      target_list() const;
  // repeated .pg_query.Node update_colnos = 6 [json_name = "updateColnos"];
  int update_colnos_size() const;
  private:
  int _internal_update_colnos_size() const;

  public:
  void clear_update_colnos() ;
  ::pg_query::Node* mutable_update_colnos(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_update_colnos();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_update_colnos() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_update_colnos();
  public:
  const ::pg_query::Node& update_colnos(int index) const;
  ::pg_query::Node* add_update_colnos();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      update_colnos() const;
  // .pg_query.Node qual = 4 [json_name = "qual"];
  bool has_qual() const;
  void clear_qual() ;
  const ::pg_query::Node& qual() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_qual();
  ::pg_query::Node* mutable_qual();
  void set_allocated_qual(::pg_query::Node* value);
  void unsafe_arena_set_allocated_qual(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_qual();

  private:
  const ::pg_query::Node& _internal_qual() const;
  ::pg_query::Node* _internal_mutable_qual();

  public:
  // bool matched = 1 [json_name = "matched"];
  void clear_matched() ;
  bool matched() const;
  void set_matched(bool value);

  private:
  bool _internal_matched() const;
  void _internal_set_matched(bool value);

  public:
  // .pg_query.CmdType command_type = 2 [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.OverridingKind override = 3 [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.MergeAction)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > target_list_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > update_colnos_;
    ::pg_query::Node* qual_;
    bool matched_;
    int command_type_;
    int override_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class MergeStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.MergeStmt) */ {
 public:
  inline MergeStmt() : MergeStmt(nullptr) {}
  ~MergeStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR MergeStmt(::google::protobuf::internal::ConstantInitialized);

  inline MergeStmt(const MergeStmt& from)
      : MergeStmt(nullptr, from) {}
  MergeStmt(MergeStmt&& from) noexcept
    : MergeStmt() {
    *this = ::std::move(from);
  }

  inline MergeStmt& operator=(const MergeStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline MergeStmt& operator=(MergeStmt&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MergeStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const MergeStmt* internal_default_instance() {
    return reinterpret_cast<const MergeStmt*>(
               &_MergeStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    130;

  friend void swap(MergeStmt& a, MergeStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(MergeStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MergeStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MergeStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MergeStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const MergeStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const MergeStmt& from) {
    MergeStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(MergeStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.MergeStmt";
  }
  protected:
  explicit MergeStmt(::google::protobuf::Arena* arena);
  MergeStmt(::google::protobuf::Arena* arena, const MergeStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMergeWhenClausesFieldNumber = 4,
    kRelationFieldNumber = 1,
    kSourceRelationFieldNumber = 2,
    kJoinConditionFieldNumber = 3,
    kWithClauseFieldNumber = 5,
  };
  // repeated .pg_query.Node merge_when_clauses = 4 [json_name = "mergeWhenClauses"];
  int merge_when_clauses_size() const;
  private:
  int _internal_merge_when_clauses_size() const;

  public:
  void clear_merge_when_clauses() ;
  ::pg_query::Node* mutable_merge_when_clauses(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_merge_when_clauses();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_merge_when_clauses() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_merge_when_clauses();
  public:
  const ::pg_query::Node& merge_when_clauses(int index) const;
  ::pg_query::Node* add_merge_when_clauses();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      merge_when_clauses() const;
  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node source_relation = 2 [json_name = "sourceRelation"];
  bool has_source_relation() const;
  void clear_source_relation() ;
  const ::pg_query::Node& source_relation() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_source_relation();
  ::pg_query::Node* mutable_source_relation();
  void set_allocated_source_relation(::pg_query::Node* value);
  void unsafe_arena_set_allocated_source_relation(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_source_relation();

  private:
  const ::pg_query::Node& _internal_source_relation() const;
  ::pg_query::Node* _internal_mutable_source_relation();

  public:
  // .pg_query.Node join_condition = 3 [json_name = "joinCondition"];
  bool has_join_condition() const;
  void clear_join_condition() ;
  const ::pg_query::Node& join_condition() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_join_condition();
  ::pg_query::Node* mutable_join_condition();
  void set_allocated_join_condition(::pg_query::Node* value);
  void unsafe_arena_set_allocated_join_condition(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_join_condition();

  private:
  const ::pg_query::Node& _internal_join_condition() const;
  ::pg_query::Node* _internal_mutable_join_condition();

  public:
  // .pg_query.WithClause with_clause = 5 [json_name = "withClause"];
  bool has_with_clause() const;
  void clear_with_clause() ;
  const ::pg_query::WithClause& with_clause() const;
  PROTOBUF_NODISCARD ::pg_query::WithClause* release_with_clause();
  ::pg_query::WithClause* mutable_with_clause();
  void set_allocated_with_clause(::pg_query::WithClause* value);
  void unsafe_arena_set_allocated_with_clause(::pg_query::WithClause* value);
  ::pg_query::WithClause* unsafe_arena_release_with_clause();

  private:
  const ::pg_query::WithClause& _internal_with_clause() const;
  ::pg_query::WithClause* _internal_mutable_with_clause();

  public:
  // @@protoc_insertion_point(class_scope:pg_query.MergeStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 5,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > merge_when_clauses_;
    ::pg_query::RangeVar* relation_;
    ::pg_query::Node* source_relation_;
    ::pg_query::Node* join_condition_;
    ::pg_query::WithClause* with_clause_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class MergeWhenClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.MergeWhenClause) */ {
 public:
  inline MergeWhenClause() : MergeWhenClause(nullptr) {}
  ~MergeWhenClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR MergeWhenClause(::google::protobuf::internal::ConstantInitialized);

  inline MergeWhenClause(const MergeWhenClause& from)
      : MergeWhenClause(nullptr, from) {}
  MergeWhenClause(MergeWhenClause&& from) noexcept
    : MergeWhenClause() {
    *this = ::std::move(from);
  }

  inline MergeWhenClause& operator=(const MergeWhenClause& from) {
    CopyFrom(from);
    return *this;
  }
  inline MergeWhenClause& operator=(MergeWhenClause&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MergeWhenClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const MergeWhenClause* internal_default_instance() {
    return reinterpret_cast<const MergeWhenClause*>(
               &_MergeWhenClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    115;

  friend void swap(MergeWhenClause& a, MergeWhenClause& b) {
    a.Swap(&b);
  }
  inline void Swap(MergeWhenClause* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MergeWhenClause* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MergeWhenClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MergeWhenClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const MergeWhenClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const MergeWhenClause& from) {
    MergeWhenClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(MergeWhenClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.MergeWhenClause";
  }
  protected:
  explicit MergeWhenClause(::google::protobuf::Arena* arena);
  MergeWhenClause(::google::protobuf::Arena* arena, const MergeWhenClause& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTargetListFieldNumber = 5,
    kValuesFieldNumber = 6,
    kConditionFieldNumber = 4,
    kMatchedFieldNumber = 1,
    kCommandTypeFieldNumber = 2,
    kOverrideFieldNumber = 3,
  };
  // repeated .pg_query.Node target_list = 5 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_target_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_target_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_target_list();
  public:
  const ::pg_query::Node& target_list(int index) const;
  ::pg_query::Node* add_target_list();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      target_list() const;
  // repeated .pg_query.Node values = 6 [json_name = "values"];
  int values_size() const;
  private:
  int _internal_values_size() const;

  public:
  void clear_values() ;
  ::pg_query::Node* mutable_values(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_values();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_values() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_values();
  public:
  const ::pg_query::Node& values(int index) const;
  ::pg_query::Node* add_values();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      values() const;
  // .pg_query.Node condition = 4 [json_name = "condition"];
  bool has_condition() const;
  void clear_condition() ;
  const ::pg_query::Node& condition() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_condition();
  ::pg_query::Node* mutable_condition();
  void set_allocated_condition(::pg_query::Node* value);
  void unsafe_arena_set_allocated_condition(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_condition();

  private:
  const ::pg_query::Node& _internal_condition() const;
  ::pg_query::Node* _internal_mutable_condition();

  public:
  // bool matched = 1 [json_name = "matched"];
  void clear_matched() ;
  bool matched() const;
  void set_matched(bool value);

  private:
  bool _internal_matched() const;
  void _internal_set_matched(bool value);

  public:
  // .pg_query.CmdType command_type = 2 [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.OverridingKind override = 3 [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.MergeWhenClause)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > target_list_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > values_;
    ::pg_query::Node* condition_;
    bool matched_;
    int command_type_;
    int override_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class MinMaxExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.MinMaxExpr) */ {
 public:
  inline MinMaxExpr() : MinMaxExpr(nullptr) {}
  ~MinMaxExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR MinMaxExpr(::google::protobuf::internal::ConstantInitialized);

  inline MinMaxExpr(const MinMaxExpr& from)
      : MinMaxExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MinMaxExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MinMaxExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MinMaxExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MinMaxExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const MinMaxExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const MinMaxExpr& from) {
    MinMaxExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(MinMaxExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.MinMaxExpr";
  }
  protected:
  explicit MinMaxExpr(::google::protobuf::Arena* arena);
  MinMaxExpr(::google::protobuf::Arena* arena, const MinMaxExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 minmaxtype = 2 [json_name = "minmaxtype"];
  void clear_minmaxtype() ;
  ::uint32_t minmaxtype() const;
  void set_minmaxtype(::uint32_t value);

  private:
  ::uint32_t _internal_minmaxtype() const;
  void _internal_set_minmaxtype(::uint32_t value);

  public:
  // uint32 minmaxcollid = 3 [json_name = "minmaxcollid"];
  void clear_minmaxcollid() ;
  ::uint32_t minmaxcollid() const;
  void set_minmaxcollid(::uint32_t value);

  private:
  ::uint32_t _internal_minmaxcollid() const;
  void _internal_set_minmaxcollid(::uint32_t value);

  public:
  // uint32 inputcollid = 4 [json_name = "inputcollid"];
  void clear_inputcollid() ;
  ::uint32_t inputcollid() const;
  void set_inputcollid(::uint32_t value);

  private:
  ::uint32_t _internal_inputcollid() const;
  void _internal_set_inputcollid(::uint32_t 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.MinMaxExpr)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* xpr_;
    ::uint32_t minmaxtype_;
    ::uint32_t minmaxcollid_;
    ::uint32_t inputcollid_;
    int op_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class MultiAssignRef final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.MultiAssignRef) */ {
 public:
  inline MultiAssignRef() : MultiAssignRef(nullptr) {}
  ~MultiAssignRef() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR MultiAssignRef(::google::protobuf::internal::ConstantInitialized);

  inline MultiAssignRef(const MultiAssignRef& from)
      : MultiAssignRef(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MultiAssignRef& default_instance() {
    return *internal_default_instance();
  }
  static inline const MultiAssignRef* internal_default_instance() {
    return reinterpret_cast<const MultiAssignRef*>(
               &_MultiAssignRef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    81;

  friend void swap(MultiAssignRef& a, MultiAssignRef& b) {
    a.Swap(&b);
  }
  inline void Swap(MultiAssignRef* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MultiAssignRef* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MultiAssignRef* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MultiAssignRef>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const MultiAssignRef& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const MultiAssignRef& from) {
    MultiAssignRef::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(MultiAssignRef* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.MultiAssignRef";
  }
  protected:
  explicit MultiAssignRef(::google::protobuf::Arena* arena);
  MultiAssignRef(::google::protobuf::Arena* arena, const MultiAssignRef& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSourceFieldNumber = 1,
    kColnoFieldNumber = 2,
    kNcolumnsFieldNumber = 3,
  };
  // .pg_query.Node source = 1 [json_name = "source"];
  bool has_source() const;
  void clear_source() ;
  const ::pg_query::Node& source() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_source();
  ::pg_query::Node* mutable_source();
  void set_allocated_source(::pg_query::Node* value);
  void unsafe_arena_set_allocated_source(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_source();

  private:
  const ::pg_query::Node& _internal_source() const;
  ::pg_query::Node* _internal_mutable_source();

  public:
  // int32 colno = 2 [json_name = "colno"];
  void clear_colno() ;
  ::int32_t colno() const;
  void set_colno(::int32_t value);

  private:
  ::int32_t _internal_colno() const;
  void _internal_set_colno(::int32_t value);

  public:
  // int32 ncolumns = 3 [json_name = "ncolumns"];
  void clear_ncolumns() ;
  ::int32_t ncolumns() const;
  void set_ncolumns(::int32_t value);

  private:
  ::int32_t _internal_ncolumns() const;
  void _internal_set_ncolumns(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.MultiAssignRef)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* source_;
    ::int32_t colno_;
    ::int32_t ncolumns_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class NamedArgExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.NamedArgExpr) */ {
 public:
  inline NamedArgExpr() : NamedArgExpr(nullptr) {}
  ~NamedArgExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR NamedArgExpr(::google::protobuf::internal::ConstantInitialized);

  inline NamedArgExpr(const NamedArgExpr& from)
      : NamedArgExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NamedArgExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NamedArgExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  NamedArgExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NamedArgExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const NamedArgExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const NamedArgExpr& from) {
    NamedArgExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(NamedArgExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.NamedArgExpr";
  }
  protected:
  explicit NamedArgExpr(::google::protobuf::Arena* arena);
  NamedArgExpr(::google::protobuf::Arena* arena, const NamedArgExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  void clear_arg() ;
  const ::pg_query::Node& arg() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* value);
  void unsafe_arena_set_allocated_arg(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_arg();

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // int32 argnumber = 4 [json_name = "argnumber"];
  void clear_argnumber() ;
  ::int32_t argnumber() const;
  void set_argnumber(::int32_t value);

  private:
  ::int32_t _internal_argnumber() const;
  void _internal_set_argnumber(::int32_t value);

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.NamedArgExpr)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      34, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* arg_;
    ::int32_t argnumber_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class NextValueExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.NextValueExpr) */ {
 public:
  inline NextValueExpr() : NextValueExpr(nullptr) {}
  ~NextValueExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR NextValueExpr(::google::protobuf::internal::ConstantInitialized);

  inline NextValueExpr(const NextValueExpr& from)
      : NextValueExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NextValueExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const NextValueExpr* internal_default_instance() {
    return reinterpret_cast<const NextValueExpr*>(
               &_NextValueExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    60;

  friend void swap(NextValueExpr& a, NextValueExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(NextValueExpr* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NextValueExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  NextValueExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NextValueExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const NextValueExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const NextValueExpr& from) {
    NextValueExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(NextValueExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.NextValueExpr";
  }
  protected:
  explicit NextValueExpr(::google::protobuf::Arena* arena);
  NextValueExpr(::google::protobuf::Arena* arena, const NextValueExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kXprFieldNumber = 1,
    kSeqidFieldNumber = 2,
    kTypeIdFieldNumber = 3,
  };
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 seqid = 2 [json_name = "seqid"];
  void clear_seqid() ;
  ::uint32_t seqid() const;
  void set_seqid(::uint32_t value);

  private:
  ::uint32_t _internal_seqid() const;
  void _internal_set_seqid(::uint32_t value);

  public:
  // uint32 type_id = 3 [json_name = "typeId"];
  void clear_type_id() ;
  ::uint32_t type_id() const;
  void set_type_id(::uint32_t value);

  private:
  ::uint32_t _internal_type_id() const;
  void _internal_set_type_id(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.NextValueExpr)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::uint32_t seqid_;
    ::uint32_t type_id_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class Node final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.Node) */ {
 public:
  inline Node() : Node(nullptr) {}
  ~Node() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Node(::google::protobuf::internal::ConstantInitialized);

  inline Node(const Node& from)
      : Node(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Node& default_instance() {
    return *internal_default_instance();
  }
  enum NodeCase {
    kAlias = 1,
    kRangeVar = 2,
    kTableFunc = 3,
    kIntoClause = 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,
    kJsonFormat = 38,
    kJsonReturning = 39,
    kJsonValueExpr = 40,
    kJsonConstructorExpr = 41,
    kJsonIsPredicate = 42,
    kNullTest = 43,
    kBooleanTest = 44,
    kCoerceToDomain = 45,
    kCoerceToDomainValue = 46,
    kSetToDefault = 47,
    kCurrentOfExpr = 48,
    kNextValueExpr = 49,
    kInferenceElem = 50,
    kTargetEntry = 51,
    kRangeTblRef = 52,
    kJoinExpr = 53,
    kFromExpr = 54,
    kOnConflictExpr = 55,
    kQuery = 56,
    kTypeName = 57,
    kColumnRef = 58,
    kParamRef = 59,
    kAExpr = 60,
    kTypeCast = 61,
    kCollateClause = 62,
    kRoleSpec = 63,
    kFuncCall = 64,
    kAStar = 65,
    kAIndices = 66,
    kAIndirection = 67,
    kAArrayExpr = 68,
    kResTarget = 69,
    kMultiAssignRef = 70,
    kSortBy = 71,
    kWindowDef = 72,
    kRangeSubselect = 73,
    kRangeFunction = 74,
    kRangeTableFunc = 75,
    kRangeTableFuncCol = 76,
    kRangeTableSample = 77,
    kColumnDef = 78,
    kTableLikeClause = 79,
    kIndexElem = 80,
    kDefElem = 81,
    kLockingClause = 82,
    kXmlSerialize = 83,
    kPartitionElem = 84,
    kPartitionSpec = 85,
    kPartitionBoundSpec = 86,
    kPartitionRangeDatum = 87,
    kPartitionCmd = 88,
    kRangeTblEntry = 89,
    kRtepermissionInfo = 90,
    kRangeTblFunction = 91,
    kTableSampleClause = 92,
    kWithCheckOption = 93,
    kSortGroupClause = 94,
    kGroupingSet = 95,
    kWindowClause = 96,
    kRowMarkClause = 97,
    kWithClause = 98,
    kInferClause = 99,
    kOnConflictClause = 100,
    kCtesearchClause = 101,
    kCtecycleClause = 102,
    kCommonTableExpr = 103,
    kMergeWhenClause = 104,
    kMergeAction = 105,
    kTriggerTransition = 106,
    kJsonOutput = 107,
    kJsonKeyValue = 108,
    kJsonObjectConstructor = 109,
    kJsonArrayConstructor = 110,
    kJsonArrayQueryConstructor = 111,
    kJsonAggConstructor = 112,
    kJsonObjectAgg = 113,
    kJsonArrayAgg = 114,
    kRawStmt = 115,
    kInsertStmt = 116,
    kDeleteStmt = 117,
    kUpdateStmt = 118,
    kMergeStmt = 119,
    kSelectStmt = 120,
    kSetOperationStmt = 121,
    kReturnStmt = 122,
    kPlassignStmt = 123,
    kCreateSchemaStmt = 124,
    kAlterTableStmt = 125,
    kReplicaIdentityStmt = 126,
    kAlterTableCmd = 127,
    kAlterCollationStmt = 128,
    kAlterDomainStmt = 129,
    kGrantStmt = 130,
    kObjectWithArgs = 131,
    kAccessPriv = 132,
    kGrantRoleStmt = 133,
    kAlterDefaultPrivilegesStmt = 134,
    kCopyStmt = 135,
    kVariableSetStmt = 136,
    kVariableShowStmt = 137,
    kCreateStmt = 138,
    kConstraint = 139,
    kCreateTableSpaceStmt = 140,
    kDropTableSpaceStmt = 141,
    kAlterTableSpaceOptionsStmt = 142,
    kAlterTableMoveAllStmt = 143,
    kCreateExtensionStmt = 144,
    kAlterExtensionStmt = 145,
    kAlterExtensionContentsStmt = 146,
    kCreateFdwStmt = 147,
    kAlterFdwStmt = 148,
    kCreateForeignServerStmt = 149,
    kAlterForeignServerStmt = 150,
    kCreateForeignTableStmt = 151,
    kCreateUserMappingStmt = 152,
    kAlterUserMappingStmt = 153,
    kDropUserMappingStmt = 154,
    kImportForeignSchemaStmt = 155,
    kCreatePolicyStmt = 156,
    kAlterPolicyStmt = 157,
    kCreateAmStmt = 158,
    kCreateTrigStmt = 159,
    kCreateEventTrigStmt = 160,
    kAlterEventTrigStmt = 161,
    kCreatePlangStmt = 162,
    kCreateRoleStmt = 163,
    kAlterRoleStmt = 164,
    kAlterRoleSetStmt = 165,
    kDropRoleStmt = 166,
    kCreateSeqStmt = 167,
    kAlterSeqStmt = 168,
    kDefineStmt = 169,
    kCreateDomainStmt = 170,
    kCreateOpClassStmt = 171,
    kCreateOpClassItem = 172,
    kCreateOpFamilyStmt = 173,
    kAlterOpFamilyStmt = 174,
    kDropStmt = 175,
    kTruncateStmt = 176,
    kCommentStmt = 177,
    kSecLabelStmt = 178,
    kDeclareCursorStmt = 179,
    kClosePortalStmt = 180,
    kFetchStmt = 181,
    kIndexStmt = 182,
    kCreateStatsStmt = 183,
    kStatsElem = 184,
    kAlterStatsStmt = 185,
    kCreateFunctionStmt = 186,
    kFunctionParameter = 187,
    kAlterFunctionStmt = 188,
    kDoStmt = 189,
    kInlineCodeBlock = 190,
    kCallStmt = 191,
    kCallContext = 192,
    kRenameStmt = 193,
    kAlterObjectDependsStmt = 194,
    kAlterObjectSchemaStmt = 195,
    kAlterOwnerStmt = 196,
    kAlterOperatorStmt = 197,
    kAlterTypeStmt = 198,
    kRuleStmt = 199,
    kNotifyStmt = 200,
    kListenStmt = 201,
    kUnlistenStmt = 202,
    kTransactionStmt = 203,
    kCompositeTypeStmt = 204,
    kCreateEnumStmt = 205,
    kCreateRangeStmt = 206,
    kAlterEnumStmt = 207,
    kViewStmt = 208,
    kLoadStmt = 209,
    kCreatedbStmt = 210,
    kAlterDatabaseStmt = 211,
    kAlterDatabaseRefreshCollStmt = 212,
    kAlterDatabaseSetStmt = 213,
    kDropdbStmt = 214,
    kAlterSystemStmt = 215,
    kClusterStmt = 216,
    kVacuumStmt = 217,
    kVacuumRelation = 218,
    kExplainStmt = 219,
    kCreateTableAsStmt = 220,
    kRefreshMatViewStmt = 221,
    kCheckPointStmt = 222,
    kDiscardStmt = 223,
    kLockStmt = 224,
    kConstraintsSetStmt = 225,
    kReindexStmt = 226,
    kCreateConversionStmt = 227,
    kCreateCastStmt = 228,
    kCreateTransformStmt = 229,
    kPrepareStmt = 230,
    kExecuteStmt = 231,
    kDeallocateStmt = 232,
    kDropOwnedStmt = 233,
    kReassignOwnedStmt = 234,
    kAlterTsdictionaryStmt = 235,
    kAlterTsconfigurationStmt = 236,
    kPublicationTable = 237,
    kPublicationObjSpec = 238,
    kCreatePublicationStmt = 239,
    kAlterPublicationStmt = 240,
    kCreateSubscriptionStmt = 241,
    kAlterSubscriptionStmt = 242,
    kDropSubscriptionStmt = 243,
    kInteger = 244,
    kFloat = 245,
    kBoolean = 246,
    kString = 247,
    kBitString = 248,
    kList = 249,
    kIntList = 250,
    kOidList = 251,
    kAConst = 252,
    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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Node* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Node* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Node>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Node& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const Node& from) {
    Node::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(Node* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.Node";
  }
  protected:
  explicit Node(::google::protobuf::Arena* arena);
  Node(::google::protobuf::Arena* arena, const Node& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAliasFieldNumber = 1,
    kRangeVarFieldNumber = 2,
    kTableFuncFieldNumber = 3,
    kIntoClauseFieldNumber = 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,
    kJsonFormatFieldNumber = 38,
    kJsonReturningFieldNumber = 39,
    kJsonValueExprFieldNumber = 40,
    kJsonConstructorExprFieldNumber = 41,
    kJsonIsPredicateFieldNumber = 42,
    kNullTestFieldNumber = 43,
    kBooleanTestFieldNumber = 44,
    kCoerceToDomainFieldNumber = 45,
    kCoerceToDomainValueFieldNumber = 46,
    kSetToDefaultFieldNumber = 47,
    kCurrentOfExprFieldNumber = 48,
    kNextValueExprFieldNumber = 49,
    kInferenceElemFieldNumber = 50,
    kTargetEntryFieldNumber = 51,
    kRangeTblRefFieldNumber = 52,
    kJoinExprFieldNumber = 53,
    kFromExprFieldNumber = 54,
    kOnConflictExprFieldNumber = 55,
    kQueryFieldNumber = 56,
    kTypeNameFieldNumber = 57,
    kColumnRefFieldNumber = 58,
    kParamRefFieldNumber = 59,
    kAExprFieldNumber = 60,
    kTypeCastFieldNumber = 61,
    kCollateClauseFieldNumber = 62,
    kRoleSpecFieldNumber = 63,
    kFuncCallFieldNumber = 64,
    kAStarFieldNumber = 65,
    kAIndicesFieldNumber = 66,
    kAIndirectionFieldNumber = 67,
    kAArrayExprFieldNumber = 68,
    kResTargetFieldNumber = 69,
    kMultiAssignRefFieldNumber = 70,
    kSortByFieldNumber = 71,
    kWindowDefFieldNumber = 72,
    kRangeSubselectFieldNumber = 73,
    kRangeFunctionFieldNumber = 74,
    kRangeTableFuncFieldNumber = 75,
    kRangeTableFuncColFieldNumber = 76,
    kRangeTableSampleFieldNumber = 77,
    kColumnDefFieldNumber = 78,
    kTableLikeClauseFieldNumber = 79,
    kIndexElemFieldNumber = 80,
    kDefElemFieldNumber = 81,
    kLockingClauseFieldNumber = 82,
    kXmlSerializeFieldNumber = 83,
    kPartitionElemFieldNumber = 84,
    kPartitionSpecFieldNumber = 85,
    kPartitionBoundSpecFieldNumber = 86,
    kPartitionRangeDatumFieldNumber = 87,
    kPartitionCmdFieldNumber = 88,
    kRangeTblEntryFieldNumber = 89,
    kRtepermissionInfoFieldNumber = 90,
    kRangeTblFunctionFieldNumber = 91,
    kTableSampleClauseFieldNumber = 92,
    kWithCheckOptionFieldNumber = 93,
    kSortGroupClauseFieldNumber = 94,
    kGroupingSetFieldNumber = 95,
    kWindowClauseFieldNumber = 96,
    kRowMarkClauseFieldNumber = 97,
    kWithClauseFieldNumber = 98,
    kInferClauseFieldNumber = 99,
    kOnConflictClauseFieldNumber = 100,
    kCtesearchClauseFieldNumber = 101,
    kCtecycleClauseFieldNumber = 102,
    kCommonTableExprFieldNumber = 103,
    kMergeWhenClauseFieldNumber = 104,
    kMergeActionFieldNumber = 105,
    kTriggerTransitionFieldNumber = 106,
    kJsonOutputFieldNumber = 107,
    kJsonKeyValueFieldNumber = 108,
    kJsonObjectConstructorFieldNumber = 109,
    kJsonArrayConstructorFieldNumber = 110,
    kJsonArrayQueryConstructorFieldNumber = 111,
    kJsonAggConstructorFieldNumber = 112,
    kJsonObjectAggFieldNumber = 113,
    kJsonArrayAggFieldNumber = 114,
    kRawStmtFieldNumber = 115,
    kInsertStmtFieldNumber = 116,
    kDeleteStmtFieldNumber = 117,
    kUpdateStmtFieldNumber = 118,
    kMergeStmtFieldNumber = 119,
    kSelectStmtFieldNumber = 120,
    kSetOperationStmtFieldNumber = 121,
    kReturnStmtFieldNumber = 122,
    kPlassignStmtFieldNumber = 123,
    kCreateSchemaStmtFieldNumber = 124,
    kAlterTableStmtFieldNumber = 125,
    kReplicaIdentityStmtFieldNumber = 126,
    kAlterTableCmdFieldNumber = 127,
    kAlterCollationStmtFieldNumber = 128,
    kAlterDomainStmtFieldNumber = 129,
    kGrantStmtFieldNumber = 130,
    kObjectWithArgsFieldNumber = 131,
    kAccessPrivFieldNumber = 132,
    kGrantRoleStmtFieldNumber = 133,
    kAlterDefaultPrivilegesStmtFieldNumber = 134,
    kCopyStmtFieldNumber = 135,
    kVariableSetStmtFieldNumber = 136,
    kVariableShowStmtFieldNumber = 137,
    kCreateStmtFieldNumber = 138,
    kConstraintFieldNumber = 139,
    kCreateTableSpaceStmtFieldNumber = 140,
    kDropTableSpaceStmtFieldNumber = 141,
    kAlterTableSpaceOptionsStmtFieldNumber = 142,
    kAlterTableMoveAllStmtFieldNumber = 143,
    kCreateExtensionStmtFieldNumber = 144,
    kAlterExtensionStmtFieldNumber = 145,
    kAlterExtensionContentsStmtFieldNumber = 146,
    kCreateFdwStmtFieldNumber = 147,
    kAlterFdwStmtFieldNumber = 148,
    kCreateForeignServerStmtFieldNumber = 149,
    kAlterForeignServerStmtFieldNumber = 150,
    kCreateForeignTableStmtFieldNumber = 151,
    kCreateUserMappingStmtFieldNumber = 152,
    kAlterUserMappingStmtFieldNumber = 153,
    kDropUserMappingStmtFieldNumber = 154,
    kImportForeignSchemaStmtFieldNumber = 155,
    kCreatePolicyStmtFieldNumber = 156,
    kAlterPolicyStmtFieldNumber = 157,
    kCreateAmStmtFieldNumber = 158,
    kCreateTrigStmtFieldNumber = 159,
    kCreateEventTrigStmtFieldNumber = 160,
    kAlterEventTrigStmtFieldNumber = 161,
    kCreatePlangStmtFieldNumber = 162,
    kCreateRoleStmtFieldNumber = 163,
    kAlterRoleStmtFieldNumber = 164,
    kAlterRoleSetStmtFieldNumber = 165,
    kDropRoleStmtFieldNumber = 166,
    kCreateSeqStmtFieldNumber = 167,
    kAlterSeqStmtFieldNumber = 168,
    kDefineStmtFieldNumber = 169,
    kCreateDomainStmtFieldNumber = 170,
    kCreateOpClassStmtFieldNumber = 171,
    kCreateOpClassItemFieldNumber = 172,
    kCreateOpFamilyStmtFieldNumber = 173,
    kAlterOpFamilyStmtFieldNumber = 174,
    kDropStmtFieldNumber = 175,
    kTruncateStmtFieldNumber = 176,
    kCommentStmtFieldNumber = 177,
    kSecLabelStmtFieldNumber = 178,
    kDeclareCursorStmtFieldNumber = 179,
    kClosePortalStmtFieldNumber = 180,
    kFetchStmtFieldNumber = 181,
    kIndexStmtFieldNumber = 182,
    kCreateStatsStmtFieldNumber = 183,
    kStatsElemFieldNumber = 184,
    kAlterStatsStmtFieldNumber = 185,
    kCreateFunctionStmtFieldNumber = 186,
    kFunctionParameterFieldNumber = 187,
    kAlterFunctionStmtFieldNumber = 188,
    kDoStmtFieldNumber = 189,
    kInlineCodeBlockFieldNumber = 190,
    kCallStmtFieldNumber = 191,
    kCallContextFieldNumber = 192,
    kRenameStmtFieldNumber = 193,
    kAlterObjectDependsStmtFieldNumber = 194,
    kAlterObjectSchemaStmtFieldNumber = 195,
    kAlterOwnerStmtFieldNumber = 196,
    kAlterOperatorStmtFieldNumber = 197,
    kAlterTypeStmtFieldNumber = 198,
    kRuleStmtFieldNumber = 199,
    kNotifyStmtFieldNumber = 200,
    kListenStmtFieldNumber = 201,
    kUnlistenStmtFieldNumber = 202,
    kTransactionStmtFieldNumber = 203,
    kCompositeTypeStmtFieldNumber = 204,
    kCreateEnumStmtFieldNumber = 205,
    kCreateRangeStmtFieldNumber = 206,
    kAlterEnumStmtFieldNumber = 207,
    kViewStmtFieldNumber = 208,
    kLoadStmtFieldNumber = 209,
    kCreatedbStmtFieldNumber = 210,
    kAlterDatabaseStmtFieldNumber = 211,
    kAlterDatabaseRefreshCollStmtFieldNumber = 212,
    kAlterDatabaseSetStmtFieldNumber = 213,
    kDropdbStmtFieldNumber = 214,
    kAlterSystemStmtFieldNumber = 215,
    kClusterStmtFieldNumber = 216,
    kVacuumStmtFieldNumber = 217,
    kVacuumRelationFieldNumber = 218,
    kExplainStmtFieldNumber = 219,
    kCreateTableAsStmtFieldNumber = 220,
    kRefreshMatViewStmtFieldNumber = 221,
    kCheckPointStmtFieldNumber = 222,
    kDiscardStmtFieldNumber = 223,
    kLockStmtFieldNumber = 224,
    kConstraintsSetStmtFieldNumber = 225,
    kReindexStmtFieldNumber = 226,
    kCreateConversionStmtFieldNumber = 227,
    kCreateCastStmtFieldNumber = 228,
    kCreateTransformStmtFieldNumber = 229,
    kPrepareStmtFieldNumber = 230,
    kExecuteStmtFieldNumber = 231,
    kDeallocateStmtFieldNumber = 232,
    kDropOwnedStmtFieldNumber = 233,
    kReassignOwnedStmtFieldNumber = 234,
    kAlterTsdictionaryStmtFieldNumber = 235,
    kAlterTsconfigurationStmtFieldNumber = 236,
    kPublicationTableFieldNumber = 237,
    kPublicationObjSpecFieldNumber = 238,
    kCreatePublicationStmtFieldNumber = 239,
    kAlterPublicationStmtFieldNumber = 240,
    kCreateSubscriptionStmtFieldNumber = 241,
    kAlterSubscriptionStmtFieldNumber = 242,
    kDropSubscriptionStmtFieldNumber = 243,
    kIntegerFieldNumber = 244,
    kFloatFieldNumber = 245,
    kBooleanFieldNumber = 246,
    kStringFieldNumber = 247,
    kBitStringFieldNumber = 248,
    kListFieldNumber = 249,
    kIntListFieldNumber = 250,
    kOidListFieldNumber = 251,
    kAConstFieldNumber = 252,
  };
  // .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;
  PROTOBUF_NODISCARD ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* value);
  void unsafe_arena_set_allocated_alias(::pg_query::Alias* value);
  ::pg_query::Alias* unsafe_arena_release_alias();

  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_range_var();
  ::pg_query::RangeVar* mutable_range_var();
  void set_allocated_range_var(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_range_var(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_range_var();

  private:
  const ::pg_query::RangeVar& _internal_range_var() const;
  ::pg_query::RangeVar* _internal_mutable_range_var();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::TableFunc* release_table_func();
  ::pg_query::TableFunc* mutable_table_func();
  void set_allocated_table_func(::pg_query::TableFunc* value);
  void unsafe_arena_set_allocated_table_func(::pg_query::TableFunc* value);
  ::pg_query::TableFunc* unsafe_arena_release_table_func();

  private:
  const ::pg_query::TableFunc& _internal_table_func() const;
  ::pg_query::TableFunc* _internal_mutable_table_func();

  public:
  // .pg_query.IntoClause into_clause = 4 [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;
  PROTOBUF_NODISCARD ::pg_query::IntoClause* release_into_clause();
  ::pg_query::IntoClause* mutable_into_clause();
  void set_allocated_into_clause(::pg_query::IntoClause* value);
  void unsafe_arena_set_allocated_into_clause(::pg_query::IntoClause* value);
  ::pg_query::IntoClause* unsafe_arena_release_into_clause();

  private:
  const ::pg_query::IntoClause& _internal_into_clause() const;
  ::pg_query::IntoClause* _internal_mutable_into_clause();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::Var* release_var();
  ::pg_query::Var* mutable_var();
  void set_allocated_var(::pg_query::Var* value);
  void unsafe_arena_set_allocated_var(::pg_query::Var* value);
  ::pg_query::Var* unsafe_arena_release_var();

  private:
  const ::pg_query::Var& _internal_var() const;
  ::pg_query::Var* _internal_mutable_var();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::Param* release_param();
  ::pg_query::Param* mutable_param();
  void set_allocated_param(::pg_query::Param* value);
  void unsafe_arena_set_allocated_param(::pg_query::Param* value);
  ::pg_query::Param* unsafe_arena_release_param();

  private:
  const ::pg_query::Param& _internal_param() const;
  ::pg_query::Param* _internal_mutable_param();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::Aggref* release_aggref();
  ::pg_query::Aggref* mutable_aggref();
  void set_allocated_aggref(::pg_query::Aggref* value);
  void unsafe_arena_set_allocated_aggref(::pg_query::Aggref* value);
  ::pg_query::Aggref* unsafe_arena_release_aggref();

  private:
  const ::pg_query::Aggref& _internal_aggref() const;
  ::pg_query::Aggref* _internal_mutable_aggref();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::GroupingFunc* release_grouping_func();
  ::pg_query::GroupingFunc* mutable_grouping_func();
  void set_allocated_grouping_func(::pg_query::GroupingFunc* value);
  void unsafe_arena_set_allocated_grouping_func(::pg_query::GroupingFunc* value);
  ::pg_query::GroupingFunc* unsafe_arena_release_grouping_func();

  private:
  const ::pg_query::GroupingFunc& _internal_grouping_func() const;
  ::pg_query::GroupingFunc* _internal_mutable_grouping_func();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::WindowFunc* release_window_func();
  ::pg_query::WindowFunc* mutable_window_func();
  void set_allocated_window_func(::pg_query::WindowFunc* value);
  void unsafe_arena_set_allocated_window_func(::pg_query::WindowFunc* value);
  ::pg_query::WindowFunc* unsafe_arena_release_window_func();

  private:
  const ::pg_query::WindowFunc& _internal_window_func() const;
  ::pg_query::WindowFunc* _internal_mutable_window_func();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::SubscriptingRef* release_subscripting_ref();
  ::pg_query::SubscriptingRef* mutable_subscripting_ref();
  void set_allocated_subscripting_ref(::pg_query::SubscriptingRef* value);
  void unsafe_arena_set_allocated_subscripting_ref(::pg_query::SubscriptingRef* value);
  ::pg_query::SubscriptingRef* unsafe_arena_release_subscripting_ref();

  private:
  const ::pg_query::SubscriptingRef& _internal_subscripting_ref() const;
  ::pg_query::SubscriptingRef* _internal_mutable_subscripting_ref();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::FuncExpr* release_func_expr();
  ::pg_query::FuncExpr* mutable_func_expr();
  void set_allocated_func_expr(::pg_query::FuncExpr* value);
  void unsafe_arena_set_allocated_func_expr(::pg_query::FuncExpr* value);
  ::pg_query::FuncExpr* unsafe_arena_release_func_expr();

  private:
  const ::pg_query::FuncExpr& _internal_func_expr() const;
  ::pg_query::FuncExpr* _internal_mutable_func_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::NamedArgExpr* release_named_arg_expr();
  ::pg_query::NamedArgExpr* mutable_named_arg_expr();
  void set_allocated_named_arg_expr(::pg_query::NamedArgExpr* value);
  void unsafe_arena_set_allocated_named_arg_expr(::pg_query::NamedArgExpr* value);
  ::pg_query::NamedArgExpr* unsafe_arena_release_named_arg_expr();

  private:
  const ::pg_query::NamedArgExpr& _internal_named_arg_expr() const;
  ::pg_query::NamedArgExpr* _internal_mutable_named_arg_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::OpExpr* release_op_expr();
  ::pg_query::OpExpr* mutable_op_expr();
  void set_allocated_op_expr(::pg_query::OpExpr* value);
  void unsafe_arena_set_allocated_op_expr(::pg_query::OpExpr* value);
  ::pg_query::OpExpr* unsafe_arena_release_op_expr();

  private:
  const ::pg_query::OpExpr& _internal_op_expr() const;
  ::pg_query::OpExpr* _internal_mutable_op_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::DistinctExpr* release_distinct_expr();
  ::pg_query::DistinctExpr* mutable_distinct_expr();
  void set_allocated_distinct_expr(::pg_query::DistinctExpr* value);
  void unsafe_arena_set_allocated_distinct_expr(::pg_query::DistinctExpr* value);
  ::pg_query::DistinctExpr* unsafe_arena_release_distinct_expr();

  private:
  const ::pg_query::DistinctExpr& _internal_distinct_expr() const;
  ::pg_query::DistinctExpr* _internal_mutable_distinct_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::NullIfExpr* release_null_if_expr();
  ::pg_query::NullIfExpr* mutable_null_if_expr();
  void set_allocated_null_if_expr(::pg_query::NullIfExpr* value);
  void unsafe_arena_set_allocated_null_if_expr(::pg_query::NullIfExpr* value);
  ::pg_query::NullIfExpr* unsafe_arena_release_null_if_expr();

  private:
  const ::pg_query::NullIfExpr& _internal_null_if_expr() const;
  ::pg_query::NullIfExpr* _internal_mutable_null_if_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_scalar_array_op_expr(::pg_query::ScalarArrayOpExpr* value);
  ::pg_query::ScalarArrayOpExpr* unsafe_arena_release_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:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::BoolExpr* release_bool_expr();
  ::pg_query::BoolExpr* mutable_bool_expr();
  void set_allocated_bool_expr(::pg_query::BoolExpr* value);
  void unsafe_arena_set_allocated_bool_expr(::pg_query::BoolExpr* value);
  ::pg_query::BoolExpr* unsafe_arena_release_bool_expr();

  private:
  const ::pg_query::BoolExpr& _internal_bool_expr() const;
  ::pg_query::BoolExpr* _internal_mutable_bool_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::SubLink* release_sub_link();
  ::pg_query::SubLink* mutable_sub_link();
  void set_allocated_sub_link(::pg_query::SubLink* value);
  void unsafe_arena_set_allocated_sub_link(::pg_query::SubLink* value);
  ::pg_query::SubLink* unsafe_arena_release_sub_link();

  private:
  const ::pg_query::SubLink& _internal_sub_link() const;
  ::pg_query::SubLink* _internal_mutable_sub_link();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::SubPlan* release_sub_plan();
  ::pg_query::SubPlan* mutable_sub_plan();
  void set_allocated_sub_plan(::pg_query::SubPlan* value);
  void unsafe_arena_set_allocated_sub_plan(::pg_query::SubPlan* value);
  ::pg_query::SubPlan* unsafe_arena_release_sub_plan();

  private:
  const ::pg_query::SubPlan& _internal_sub_plan() const;
  ::pg_query::SubPlan* _internal_mutable_sub_plan();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::AlternativeSubPlan* release_alternative_sub_plan();
  ::pg_query::AlternativeSubPlan* mutable_alternative_sub_plan();
  void set_allocated_alternative_sub_plan(::pg_query::AlternativeSubPlan* value);
  void unsafe_arena_set_allocated_alternative_sub_plan(::pg_query::AlternativeSubPlan* value);
  ::pg_query::AlternativeSubPlan* unsafe_arena_release_alternative_sub_plan();

  private:
  const ::pg_query::AlternativeSubPlan& _internal_alternative_sub_plan() const;
  ::pg_query::AlternativeSubPlan* _internal_mutable_alternative_sub_plan();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::FieldSelect* release_field_select();
  ::pg_query::FieldSelect* mutable_field_select();
  void set_allocated_field_select(::pg_query::FieldSelect* value);
  void unsafe_arena_set_allocated_field_select(::pg_query::FieldSelect* value);
  ::pg_query::FieldSelect* unsafe_arena_release_field_select();

  private:
  const ::pg_query::FieldSelect& _internal_field_select() const;
  ::pg_query::FieldSelect* _internal_mutable_field_select();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::FieldStore* release_field_store();
  ::pg_query::FieldStore* mutable_field_store();
  void set_allocated_field_store(::pg_query::FieldStore* value);
  void unsafe_arena_set_allocated_field_store(::pg_query::FieldStore* value);
  ::pg_query::FieldStore* unsafe_arena_release_field_store();

  private:
  const ::pg_query::FieldStore& _internal_field_store() const;
  ::pg_query::FieldStore* _internal_mutable_field_store();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::RelabelType* release_relabel_type();
  ::pg_query::RelabelType* mutable_relabel_type();
  void set_allocated_relabel_type(::pg_query::RelabelType* value);
  void unsafe_arena_set_allocated_relabel_type(::pg_query::RelabelType* value);
  ::pg_query::RelabelType* unsafe_arena_release_relabel_type();

  private:
  const ::pg_query::RelabelType& _internal_relabel_type() const;
  ::pg_query::RelabelType* _internal_mutable_relabel_type();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::CoerceViaIO* release_coerce_via_io();
  ::pg_query::CoerceViaIO* mutable_coerce_via_io();
  void set_allocated_coerce_via_io(::pg_query::CoerceViaIO* value);
  void unsafe_arena_set_allocated_coerce_via_io(::pg_query::CoerceViaIO* value);
  ::pg_query::CoerceViaIO* unsafe_arena_release_coerce_via_io();

  private:
  const ::pg_query::CoerceViaIO& _internal_coerce_via_io() const;
  ::pg_query::CoerceViaIO* _internal_mutable_coerce_via_io();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::ArrayCoerceExpr* release_array_coerce_expr();
  ::pg_query::ArrayCoerceExpr* mutable_array_coerce_expr();
  void set_allocated_array_coerce_expr(::pg_query::ArrayCoerceExpr* value);
  void unsafe_arena_set_allocated_array_coerce_expr(::pg_query::ArrayCoerceExpr* value);
  ::pg_query::ArrayCoerceExpr* unsafe_arena_release_array_coerce_expr();

  private:
  const ::pg_query::ArrayCoerceExpr& _internal_array_coerce_expr() const;
  ::pg_query::ArrayCoerceExpr* _internal_mutable_array_coerce_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::ConvertRowtypeExpr* release_convert_rowtype_expr();
  ::pg_query::ConvertRowtypeExpr* mutable_convert_rowtype_expr();
  void set_allocated_convert_rowtype_expr(::pg_query::ConvertRowtypeExpr* value);
  void unsafe_arena_set_allocated_convert_rowtype_expr(::pg_query::ConvertRowtypeExpr* value);
  ::pg_query::ConvertRowtypeExpr* unsafe_arena_release_convert_rowtype_expr();

  private:
  const ::pg_query::ConvertRowtypeExpr& _internal_convert_rowtype_expr() const;
  ::pg_query::ConvertRowtypeExpr* _internal_mutable_convert_rowtype_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::CollateExpr* release_collate_expr();
  ::pg_query::CollateExpr* mutable_collate_expr();
  void set_allocated_collate_expr(::pg_query::CollateExpr* value);
  void unsafe_arena_set_allocated_collate_expr(::pg_query::CollateExpr* value);
  ::pg_query::CollateExpr* unsafe_arena_release_collate_expr();

  private:
  const ::pg_query::CollateExpr& _internal_collate_expr() const;
  ::pg_query::CollateExpr* _internal_mutable_collate_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::CaseExpr* release_case_expr();
  ::pg_query::CaseExpr* mutable_case_expr();
  void set_allocated_case_expr(::pg_query::CaseExpr* value);
  void unsafe_arena_set_allocated_case_expr(::pg_query::CaseExpr* value);
  ::pg_query::CaseExpr* unsafe_arena_release_case_expr();

  private:
  const ::pg_query::CaseExpr& _internal_case_expr() const;
  ::pg_query::CaseExpr* _internal_mutable_case_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::CaseWhen* release_case_when();
  ::pg_query::CaseWhen* mutable_case_when();
  void set_allocated_case_when(::pg_query::CaseWhen* value);
  void unsafe_arena_set_allocated_case_when(::pg_query::CaseWhen* value);
  ::pg_query::CaseWhen* unsafe_arena_release_case_when();

  private:
  const ::pg_query::CaseWhen& _internal_case_when() const;
  ::pg_query::CaseWhen* _internal_mutable_case_when();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::CaseTestExpr* release_case_test_expr();
  ::pg_query::CaseTestExpr* mutable_case_test_expr();
  void set_allocated_case_test_expr(::pg_query::CaseTestExpr* value);
  void unsafe_arena_set_allocated_case_test_expr(::pg_query::CaseTestExpr* value);
  ::pg_query::CaseTestExpr* unsafe_arena_release_case_test_expr();

  private:
  const ::pg_query::CaseTestExpr& _internal_case_test_expr() const;
  ::pg_query::CaseTestExpr* _internal_mutable_case_test_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::ArrayExpr* release_array_expr();
  ::pg_query::ArrayExpr* mutable_array_expr();
  void set_allocated_array_expr(::pg_query::ArrayExpr* value);
  void unsafe_arena_set_allocated_array_expr(::pg_query::ArrayExpr* value);
  ::pg_query::ArrayExpr* unsafe_arena_release_array_expr();

  private:
  const ::pg_query::ArrayExpr& _internal_array_expr() const;
  ::pg_query::ArrayExpr* _internal_mutable_array_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::RowExpr* release_row_expr();
  ::pg_query::RowExpr* mutable_row_expr();
  void set_allocated_row_expr(::pg_query::RowExpr* value);
  void unsafe_arena_set_allocated_row_expr(::pg_query::RowExpr* value);
  ::pg_query::RowExpr* unsafe_arena_release_row_expr();

  private:
  const ::pg_query::RowExpr& _internal_row_expr() const;
  ::pg_query::RowExpr* _internal_mutable_row_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::RowCompareExpr* release_row_compare_expr();
  ::pg_query::RowCompareExpr* mutable_row_compare_expr();
  void set_allocated_row_compare_expr(::pg_query::RowCompareExpr* value);
  void unsafe_arena_set_allocated_row_compare_expr(::pg_query::RowCompareExpr* value);
  ::pg_query::RowCompareExpr* unsafe_arena_release_row_compare_expr();

  private:
  const ::pg_query::RowCompareExpr& _internal_row_compare_expr() const;
  ::pg_query::RowCompareExpr* _internal_mutable_row_compare_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::CoalesceExpr* release_coalesce_expr();
  ::pg_query::CoalesceExpr* mutable_coalesce_expr();
  void set_allocated_coalesce_expr(::pg_query::CoalesceExpr* value);
  void unsafe_arena_set_allocated_coalesce_expr(::pg_query::CoalesceExpr* value);
  ::pg_query::CoalesceExpr* unsafe_arena_release_coalesce_expr();

  private:
  const ::pg_query::CoalesceExpr& _internal_coalesce_expr() const;
  ::pg_query::CoalesceExpr* _internal_mutable_coalesce_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::MinMaxExpr* release_min_max_expr();
  ::pg_query::MinMaxExpr* mutable_min_max_expr();
  void set_allocated_min_max_expr(::pg_query::MinMaxExpr* value);
  void unsafe_arena_set_allocated_min_max_expr(::pg_query::MinMaxExpr* value);
  ::pg_query::MinMaxExpr* unsafe_arena_release_min_max_expr();

  private:
  const ::pg_query::MinMaxExpr& _internal_min_max_expr() const;
  ::pg_query::MinMaxExpr* _internal_mutable_min_max_expr();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::SQLValueFunction* release_sqlvalue_function();
  ::pg_query::SQLValueFunction* mutable_sqlvalue_function();
  void set_allocated_sqlvalue_function(::pg_query::SQLValueFunction* value);
  void unsafe_arena_set_allocated_sqlvalue_function(::pg_query::SQLValueFunction* value);
  ::pg_query::SQLValueFunction* unsafe_arena_release_sqlvalue_function();

  private:
  const ::pg_query::SQLValueFunction& _internal_sqlvalue_function() const;
  ::pg_query::SQLValueFunction* _internal_mutable_sqlvalue_function();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::XmlExpr* release_xml_expr();
  ::pg_query::XmlExpr* mutable_xml_expr();
  void set_allocated_xml_expr(::pg_query::XmlExpr* value);
  void unsafe_arena_set_allocated_xml_expr(::pg_query::XmlExpr* value);
  ::pg_query::XmlExpr* unsafe_arena_release_xml_expr();

  private:
  const ::pg_query::XmlExpr& _internal_xml_expr() const;
  ::pg_query::XmlExpr* _internal_mutable_xml_expr();

  public:
  // .pg_query.JsonFormat json_format = 38 [json_name = "JsonFormat"];
  bool has_json_format() const;
  private:
  bool _internal_has_json_format() const;

  public:
  void clear_json_format() ;
  const ::pg_query::JsonFormat& json_format() const;
  PROTOBUF_NODISCARD ::pg_query::JsonFormat* release_json_format();
  ::pg_query::JsonFormat* mutable_json_format();
  void set_allocated_json_format(::pg_query::JsonFormat* value);
  void unsafe_arena_set_allocated_json_format(::pg_query::JsonFormat* value);
  ::pg_query::JsonFormat* unsafe_arena_release_json_format();

  private:
  const ::pg_query::JsonFormat& _internal_json_format() const;
  ::pg_query::JsonFormat* _internal_mutable_json_format();

  public:
  // .pg_query.JsonReturning json_returning = 39 [json_name = "JsonReturning"];
  bool has_json_returning() const;
  private:
  bool _internal_has_json_returning() const;

  public:
  void clear_json_returning() ;
  const ::pg_query::JsonReturning& json_returning() const;
  PROTOBUF_NODISCARD ::pg_query::JsonReturning* release_json_returning();
  ::pg_query::JsonReturning* mutable_json_returning();
  void set_allocated_json_returning(::pg_query::JsonReturning* value);
  void unsafe_arena_set_allocated_json_returning(::pg_query::JsonReturning* value);
  ::pg_query::JsonReturning* unsafe_arena_release_json_returning();

  private:
  const ::pg_query::JsonReturning& _internal_json_returning() const;
  ::pg_query::JsonReturning* _internal_mutable_json_returning();

  public:
  // .pg_query.JsonValueExpr json_value_expr = 40 [json_name = "JsonValueExpr"];
  bool has_json_value_expr() const;
  private:
  bool _internal_has_json_value_expr() const;

  public:
  void clear_json_value_expr() ;
  const ::pg_query::JsonValueExpr& json_value_expr() const;
  PROTOBUF_NODISCARD ::pg_query::JsonValueExpr* release_json_value_expr();
  ::pg_query::JsonValueExpr* mutable_json_value_expr();
  void set_allocated_json_value_expr(::pg_query::JsonValueExpr* value);
  void unsafe_arena_set_allocated_json_value_expr(::pg_query::JsonValueExpr* value);
  ::pg_query::JsonValueExpr* unsafe_arena_release_json_value_expr();

  private:
  const ::pg_query::JsonValueExpr& _internal_json_value_expr() const;
  ::pg_query::JsonValueExpr* _internal_mutable_json_value_expr();

  public:
  // .pg_query.JsonConstructorExpr json_constructor_expr = 41 [json_name = "JsonConstructorExpr"];
  bool has_json_constructor_expr() const;
  private:
  bool _internal_has_json_constructor_expr() const;

  public:
  void clear_json_constructor_expr() ;
  const ::pg_query::JsonConstructorExpr& json_constructor_expr() const;
  PROTOBUF_NODISCARD ::pg_query::JsonConstructorExpr* release_json_constructor_expr();
  ::pg_query::JsonConstructorExpr* mutable_json_constructor_expr();
  void set_allocated_json_constructor_expr(::pg_query::JsonConstructorExpr* value);
  void unsafe_arena_set_allocated_json_constructor_expr(::pg_query::JsonConstructorExpr* value);
  ::pg_query::JsonConstructorExpr* unsafe_arena_release_json_constructor_expr();

  private:
  const ::pg_query::JsonConstructorExpr& _internal_json_constructor_expr() const;
  ::pg_query::JsonConstructorExpr* _internal_mutable_json_constructor_expr();

  public:
  // .pg_query.JsonIsPredicate json_is_predicate = 42 [json_name = "JsonIsPredicate"];
  bool has_json_is_predicate() const;
  private:
  bool _internal_has_json_is_predicate() const;

  public:
  void clear_json_is_predicate() ;
  const ::pg_query::JsonIsPredicate& json_is_predicate() const;
  PROTOBUF_NODISCARD ::pg_query::JsonIsPredicate* release_json_is_predicate();
  ::pg_query::JsonIsPredicate* mutable_json_is_predicate();
  void set_allocated_json_is_predicate(::pg_query::JsonIsPredicate* value);
  void unsafe_arena_set_allocated_json_is_predicate(::pg_query::JsonIsPredicate* value);
  ::pg_query::JsonIsPredicate* unsafe_arena_release_json_is_predicate();

  private:
  const ::pg_query::JsonIsPredicate& _internal_json_is_predicate() const;
  ::pg_query::JsonIsPredicate* _internal_mutable_json_is_predicate();

  public:
  // .pg_query.NullTest null_test = 43 [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;
  PROTOBUF_NODISCARD ::pg_query::NullTest* release_null_test();
  ::pg_query::NullTest* mutable_null_test();
  void set_allocated_null_test(::pg_query::NullTest* value);
  void unsafe_arena_set_allocated_null_test(::pg_query::NullTest* value);
  ::pg_query::NullTest* unsafe_arena_release_null_test();

  private:
  const ::pg_query::NullTest& _internal_null_test() const;
  ::pg_query::NullTest* _internal_mutable_null_test();

  public:
  // .pg_query.BooleanTest boolean_test = 44 [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;
  PROTOBUF_NODISCARD ::pg_query::BooleanTest* release_boolean_test();
  ::pg_query::BooleanTest* mutable_boolean_test();
  void set_allocated_boolean_test(::pg_query::BooleanTest* value);
  void unsafe_arena_set_allocated_boolean_test(::pg_query::BooleanTest* value);
  ::pg_query::BooleanTest* unsafe_arena_release_boolean_test();

  private:
  const ::pg_query::BooleanTest& _internal_boolean_test() const;
  ::pg_query::BooleanTest* _internal_mutable_boolean_test();

  public:
  // .pg_query.CoerceToDomain coerce_to_domain = 45 [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;
  PROTOBUF_NODISCARD ::pg_query::CoerceToDomain* release_coerce_to_domain();
  ::pg_query::CoerceToDomain* mutable_coerce_to_domain();
  void set_allocated_coerce_to_domain(::pg_query::CoerceToDomain* value);
  void unsafe_arena_set_allocated_coerce_to_domain(::pg_query::CoerceToDomain* value);
  ::pg_query::CoerceToDomain* unsafe_arena_release_coerce_to_domain();

  private:
  const ::pg_query::CoerceToDomain& _internal_coerce_to_domain() const;
  ::pg_query::CoerceToDomain* _internal_mutable_coerce_to_domain();

  public:
  // .pg_query.CoerceToDomainValue coerce_to_domain_value = 46 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_coerce_to_domain_value(::pg_query::CoerceToDomainValue* value);
  ::pg_query::CoerceToDomainValue* unsafe_arena_release_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:
  // .pg_query.SetToDefault set_to_default = 47 [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;
  PROTOBUF_NODISCARD ::pg_query::SetToDefault* release_set_to_default();
  ::pg_query::SetToDefault* mutable_set_to_default();
  void set_allocated_set_to_default(::pg_query::SetToDefault* value);
  void unsafe_arena_set_allocated_set_to_default(::pg_query::SetToDefault* value);
  ::pg_query::SetToDefault* unsafe_arena_release_set_to_default();

  private:
  const ::pg_query::SetToDefault& _internal_set_to_default() const;
  ::pg_query::SetToDefault* _internal_mutable_set_to_default();

  public:
  // .pg_query.CurrentOfExpr current_of_expr = 48 [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;
  PROTOBUF_NODISCARD ::pg_query::CurrentOfExpr* release_current_of_expr();
  ::pg_query::CurrentOfExpr* mutable_current_of_expr();
  void set_allocated_current_of_expr(::pg_query::CurrentOfExpr* value);
  void unsafe_arena_set_allocated_current_of_expr(::pg_query::CurrentOfExpr* value);
  ::pg_query::CurrentOfExpr* unsafe_arena_release_current_of_expr();

  private:
  const ::pg_query::CurrentOfExpr& _internal_current_of_expr() const;
  ::pg_query::CurrentOfExpr* _internal_mutable_current_of_expr();

  public:
  // .pg_query.NextValueExpr next_value_expr = 49 [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;
  PROTOBUF_NODISCARD ::pg_query::NextValueExpr* release_next_value_expr();
  ::pg_query::NextValueExpr* mutable_next_value_expr();
  void set_allocated_next_value_expr(::pg_query::NextValueExpr* value);
  void unsafe_arena_set_allocated_next_value_expr(::pg_query::NextValueExpr* value);
  ::pg_query::NextValueExpr* unsafe_arena_release_next_value_expr();

  private:
  const ::pg_query::NextValueExpr& _internal_next_value_expr() const;
  ::pg_query::NextValueExpr* _internal_mutable_next_value_expr();

  public:
  // .pg_query.InferenceElem inference_elem = 50 [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;
  PROTOBUF_NODISCARD ::pg_query::InferenceElem* release_inference_elem();
  ::pg_query::InferenceElem* mutable_inference_elem();
  void set_allocated_inference_elem(::pg_query::InferenceElem* value);
  void unsafe_arena_set_allocated_inference_elem(::pg_query::InferenceElem* value);
  ::pg_query::InferenceElem* unsafe_arena_release_inference_elem();

  private:
  const ::pg_query::InferenceElem& _internal_inference_elem() const;
  ::pg_query::InferenceElem* _internal_mutable_inference_elem();

  public:
  // .pg_query.TargetEntry target_entry = 51 [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;
  PROTOBUF_NODISCARD ::pg_query::TargetEntry* release_target_entry();
  ::pg_query::TargetEntry* mutable_target_entry();
  void set_allocated_target_entry(::pg_query::TargetEntry* value);
  void unsafe_arena_set_allocated_target_entry(::pg_query::TargetEntry* value);
  ::pg_query::TargetEntry* unsafe_arena_release_target_entry();

  private:
  const ::pg_query::TargetEntry& _internal_target_entry() const;
  ::pg_query::TargetEntry* _internal_mutable_target_entry();

  public:
  // .pg_query.RangeTblRef range_tbl_ref = 52 [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;
  PROTOBUF_NODISCARD ::pg_query::RangeTblRef* release_range_tbl_ref();
  ::pg_query::RangeTblRef* mutable_range_tbl_ref();
  void set_allocated_range_tbl_ref(::pg_query::RangeTblRef* value);
  void unsafe_arena_set_allocated_range_tbl_ref(::pg_query::RangeTblRef* value);
  ::pg_query::RangeTblRef* unsafe_arena_release_range_tbl_ref();

  private:
  const ::pg_query::RangeTblRef& _internal_range_tbl_ref() const;
  ::pg_query::RangeTblRef* _internal_mutable_range_tbl_ref();

  public:
  // .pg_query.JoinExpr join_expr = 53 [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;
  PROTOBUF_NODISCARD ::pg_query::JoinExpr* release_join_expr();
  ::pg_query::JoinExpr* mutable_join_expr();
  void set_allocated_join_expr(::pg_query::JoinExpr* value);
  void unsafe_arena_set_allocated_join_expr(::pg_query::JoinExpr* value);
  ::pg_query::JoinExpr* unsafe_arena_release_join_expr();

  private:
  const ::pg_query::JoinExpr& _internal_join_expr() const;
  ::pg_query::JoinExpr* _internal_mutable_join_expr();

  public:
  // .pg_query.FromExpr from_expr = 54 [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;
  PROTOBUF_NODISCARD ::pg_query::FromExpr* release_from_expr();
  ::pg_query::FromExpr* mutable_from_expr();
  void set_allocated_from_expr(::pg_query::FromExpr* value);
  void unsafe_arena_set_allocated_from_expr(::pg_query::FromExpr* value);
  ::pg_query::FromExpr* unsafe_arena_release_from_expr();

  private:
  const ::pg_query::FromExpr& _internal_from_expr() const;
  ::pg_query::FromExpr* _internal_mutable_from_expr();

  public:
  // .pg_query.OnConflictExpr on_conflict_expr = 55 [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;
  PROTOBUF_NODISCARD ::pg_query::OnConflictExpr* release_on_conflict_expr();
  ::pg_query::OnConflictExpr* mutable_on_conflict_expr();
  void set_allocated_on_conflict_expr(::pg_query::OnConflictExpr* value);
  void unsafe_arena_set_allocated_on_conflict_expr(::pg_query::OnConflictExpr* value);
  ::pg_query::OnConflictExpr* unsafe_arena_release_on_conflict_expr();

  private:
  const ::pg_query::OnConflictExpr& _internal_on_conflict_expr() const;
  ::pg_query::OnConflictExpr* _internal_mutable_on_conflict_expr();

  public:
  // .pg_query.Query query = 56 [json_name = "Query"];
  bool has_query() const;
  private:
  bool _internal_has_query() const;

  public:
  void clear_query() ;
  const ::pg_query::Query& query() const;
  PROTOBUF_NODISCARD ::pg_query::Query* release_query();
  ::pg_query::Query* mutable_query();
  void set_allocated_query(::pg_query::Query* value);
  void unsafe_arena_set_allocated_query(::pg_query::Query* value);
  ::pg_query::Query* unsafe_arena_release_query();

  private:
  const ::pg_query::Query& _internal_query() const;
  ::pg_query::Query* _internal_mutable_query();

  public:
  // .pg_query.TypeName type_name = 57 [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;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_type_name(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();

  public:
  // .pg_query.ColumnRef column_ref = 58 [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;
  PROTOBUF_NODISCARD ::pg_query::ColumnRef* release_column_ref();
  ::pg_query::ColumnRef* mutable_column_ref();
  void set_allocated_column_ref(::pg_query::ColumnRef* value);
  void unsafe_arena_set_allocated_column_ref(::pg_query::ColumnRef* value);
  ::pg_query::ColumnRef* unsafe_arena_release_column_ref();

  private:
  const ::pg_query::ColumnRef& _internal_column_ref() const;
  ::pg_query::ColumnRef* _internal_mutable_column_ref();

  public:
  // .pg_query.ParamRef param_ref = 59 [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;
  PROTOBUF_NODISCARD ::pg_query::ParamRef* release_param_ref();
  ::pg_query::ParamRef* mutable_param_ref();
  void set_allocated_param_ref(::pg_query::ParamRef* value);
  void unsafe_arena_set_allocated_param_ref(::pg_query::ParamRef* value);
  ::pg_query::ParamRef* unsafe_arena_release_param_ref();

  private:
  const ::pg_query::ParamRef& _internal_param_ref() const;
  ::pg_query::ParamRef* _internal_mutable_param_ref();

  public:
  // .pg_query.A_Expr a_expr = 60 [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;
  PROTOBUF_NODISCARD ::pg_query::A_Expr* release_a_expr();
  ::pg_query::A_Expr* mutable_a_expr();
  void set_allocated_a_expr(::pg_query::A_Expr* value);
  void unsafe_arena_set_allocated_a_expr(::pg_query::A_Expr* value);
  ::pg_query::A_Expr* unsafe_arena_release_a_expr();

  private:
  const ::pg_query::A_Expr& _internal_a_expr() const;
  ::pg_query::A_Expr* _internal_mutable_a_expr();

  public:
  // .pg_query.TypeCast type_cast = 61 [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;
  PROTOBUF_NODISCARD ::pg_query::TypeCast* release_type_cast();
  ::pg_query::TypeCast* mutable_type_cast();
  void set_allocated_type_cast(::pg_query::TypeCast* value);
  void unsafe_arena_set_allocated_type_cast(::pg_query::TypeCast* value);
  ::pg_query::TypeCast* unsafe_arena_release_type_cast();

  private:
  const ::pg_query::TypeCast& _internal_type_cast() const;
  ::pg_query::TypeCast* _internal_mutable_type_cast();

  public:
  // .pg_query.CollateClause collate_clause = 62 [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;
  PROTOBUF_NODISCARD ::pg_query::CollateClause* release_collate_clause();
  ::pg_query::CollateClause* mutable_collate_clause();
  void set_allocated_collate_clause(::pg_query::CollateClause* value);
  void unsafe_arena_set_allocated_collate_clause(::pg_query::CollateClause* value);
  ::pg_query::CollateClause* unsafe_arena_release_collate_clause();

  private:
  const ::pg_query::CollateClause& _internal_collate_clause() const;
  ::pg_query::CollateClause* _internal_mutable_collate_clause();

  public:
  // .pg_query.RoleSpec role_spec = 63 [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;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_role_spec();
  ::pg_query::RoleSpec* mutable_role_spec();
  void set_allocated_role_spec(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_role_spec(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_role_spec();

  private:
  const ::pg_query::RoleSpec& _internal_role_spec() const;
  ::pg_query::RoleSpec* _internal_mutable_role_spec();

  public:
  // .pg_query.FuncCall func_call = 64 [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;
  PROTOBUF_NODISCARD ::pg_query::FuncCall* release_func_call();
  ::pg_query::FuncCall* mutable_func_call();
  void set_allocated_func_call(::pg_query::FuncCall* value);
  void unsafe_arena_set_allocated_func_call(::pg_query::FuncCall* value);
  ::pg_query::FuncCall* unsafe_arena_release_func_call();

  private:
  const ::pg_query::FuncCall& _internal_func_call() const;
  ::pg_query::FuncCall* _internal_mutable_func_call();

  public:
  // .pg_query.A_Star a_star = 65 [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;
  PROTOBUF_NODISCARD ::pg_query::A_Star* release_a_star();
  ::pg_query::A_Star* mutable_a_star();
  void set_allocated_a_star(::pg_query::A_Star* value);
  void unsafe_arena_set_allocated_a_star(::pg_query::A_Star* value);
  ::pg_query::A_Star* unsafe_arena_release_a_star();

  private:
  const ::pg_query::A_Star& _internal_a_star() const;
  ::pg_query::A_Star* _internal_mutable_a_star();

  public:
  // .pg_query.A_Indices a_indices = 66 [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;
  PROTOBUF_NODISCARD ::pg_query::A_Indices* release_a_indices();
  ::pg_query::A_Indices* mutable_a_indices();
  void set_allocated_a_indices(::pg_query::A_Indices* value);
  void unsafe_arena_set_allocated_a_indices(::pg_query::A_Indices* value);
  ::pg_query::A_Indices* unsafe_arena_release_a_indices();

  private:
  const ::pg_query::A_Indices& _internal_a_indices() const;
  ::pg_query::A_Indices* _internal_mutable_a_indices();

  public:
  // .pg_query.A_Indirection a_indirection = 67 [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;
  PROTOBUF_NODISCARD ::pg_query::A_Indirection* release_a_indirection();
  ::pg_query::A_Indirection* mutable_a_indirection();
  void set_allocated_a_indirection(::pg_query::A_Indirection* value);
  void unsafe_arena_set_allocated_a_indirection(::pg_query::A_Indirection* value);
  ::pg_query::A_Indirection* unsafe_arena_release_a_indirection();

  private:
  const ::pg_query::A_Indirection& _internal_a_indirection() const;
  ::pg_query::A_Indirection* _internal_mutable_a_indirection();

  public:
  // .pg_query.A_ArrayExpr a_array_expr = 68 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_a_array_expr(::pg_query::A_ArrayExpr* value);
  ::pg_query::A_ArrayExpr* unsafe_arena_release_a_array_expr();

  private:
  const ::pg_query::A_ArrayExpr& _internal_a_array_expr() const;
  ::pg_query::A_ArrayExpr* _internal_mutable_a_array_expr();

  public:
  // .pg_query.ResTarget res_target = 69 [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;
  PROTOBUF_NODISCARD ::pg_query::ResTarget* release_res_target();
  ::pg_query::ResTarget* mutable_res_target();
  void set_allocated_res_target(::pg_query::ResTarget* value);
  void unsafe_arena_set_allocated_res_target(::pg_query::ResTarget* value);
  ::pg_query::ResTarget* unsafe_arena_release_res_target();

  private:
  const ::pg_query::ResTarget& _internal_res_target() const;
  ::pg_query::ResTarget* _internal_mutable_res_target();

  public:
  // .pg_query.MultiAssignRef multi_assign_ref = 70 [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;
  PROTOBUF_NODISCARD ::pg_query::MultiAssignRef* release_multi_assign_ref();
  ::pg_query::MultiAssignRef* mutable_multi_assign_ref();
  void set_allocated_multi_assign_ref(::pg_query::MultiAssignRef* value);
  void unsafe_arena_set_allocated_multi_assign_ref(::pg_query::MultiAssignRef* value);
  ::pg_query::MultiAssignRef* unsafe_arena_release_multi_assign_ref();

  private:
  const ::pg_query::MultiAssignRef& _internal_multi_assign_ref() const;
  ::pg_query::MultiAssignRef* _internal_mutable_multi_assign_ref();

  public:
  // .pg_query.SortBy sort_by = 71 [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;
  PROTOBUF_NODISCARD ::pg_query::SortBy* release_sort_by();
  ::pg_query::SortBy* mutable_sort_by();
  void set_allocated_sort_by(::pg_query::SortBy* value);
  void unsafe_arena_set_allocated_sort_by(::pg_query::SortBy* value);
  ::pg_query::SortBy* unsafe_arena_release_sort_by();

  private:
  const ::pg_query::SortBy& _internal_sort_by() const;
  ::pg_query::SortBy* _internal_mutable_sort_by();

  public:
  // .pg_query.WindowDef window_def = 72 [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;
  PROTOBUF_NODISCARD ::pg_query::WindowDef* release_window_def();
  ::pg_query::WindowDef* mutable_window_def();
  void set_allocated_window_def(::pg_query::WindowDef* value);
  void unsafe_arena_set_allocated_window_def(::pg_query::WindowDef* value);
  ::pg_query::WindowDef* unsafe_arena_release_window_def();

  private:
  const ::pg_query::WindowDef& _internal_window_def() const;
  ::pg_query::WindowDef* _internal_mutable_window_def();

  public:
  // .pg_query.RangeSubselect range_subselect = 73 [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;
  PROTOBUF_NODISCARD ::pg_query::RangeSubselect* release_range_subselect();
  ::pg_query::RangeSubselect* mutable_range_subselect();
  void set_allocated_range_subselect(::pg_query::RangeSubselect* value);
  void unsafe_arena_set_allocated_range_subselect(::pg_query::RangeSubselect* value);
  ::pg_query::RangeSubselect* unsafe_arena_release_range_subselect();

  private:
  const ::pg_query::RangeSubselect& _internal_range_subselect() const;
  ::pg_query::RangeSubselect* _internal_mutable_range_subselect();

  public:
  // .pg_query.RangeFunction range_function = 74 [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;
  PROTOBUF_NODISCARD ::pg_query::RangeFunction* release_range_function();
  ::pg_query::RangeFunction* mutable_range_function();
  void set_allocated_range_function(::pg_query::RangeFunction* value);
  void unsafe_arena_set_allocated_range_function(::pg_query::RangeFunction* value);
  ::pg_query::RangeFunction* unsafe_arena_release_range_function();

  private:
  const ::pg_query::RangeFunction& _internal_range_function() const;
  ::pg_query::RangeFunction* _internal_mutable_range_function();

  public:
  // .pg_query.RangeTableFunc range_table_func = 75 [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;
  PROTOBUF_NODISCARD ::pg_query::RangeTableFunc* release_range_table_func();
  ::pg_query::RangeTableFunc* mutable_range_table_func();
  void set_allocated_range_table_func(::pg_query::RangeTableFunc* value);
  void unsafe_arena_set_allocated_range_table_func(::pg_query::RangeTableFunc* value);
  ::pg_query::RangeTableFunc* unsafe_arena_release_range_table_func();

  private:
  const ::pg_query::RangeTableFunc& _internal_range_table_func() const;
  ::pg_query::RangeTableFunc* _internal_mutable_range_table_func();

  public:
  // .pg_query.RangeTableFuncCol range_table_func_col = 76 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_range_table_func_col(::pg_query::RangeTableFuncCol* value);
  ::pg_query::RangeTableFuncCol* unsafe_arena_release_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:
  // .pg_query.RangeTableSample range_table_sample = 77 [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;
  PROTOBUF_NODISCARD ::pg_query::RangeTableSample* release_range_table_sample();
  ::pg_query::RangeTableSample* mutable_range_table_sample();
  void set_allocated_range_table_sample(::pg_query::RangeTableSample* value);
  void unsafe_arena_set_allocated_range_table_sample(::pg_query::RangeTableSample* value);
  ::pg_query::RangeTableSample* unsafe_arena_release_range_table_sample();

  private:
  const ::pg_query::RangeTableSample& _internal_range_table_sample() const;
  ::pg_query::RangeTableSample* _internal_mutable_range_table_sample();

  public:
  // .pg_query.ColumnDef column_def = 78 [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;
  PROTOBUF_NODISCARD ::pg_query::ColumnDef* release_column_def();
  ::pg_query::ColumnDef* mutable_column_def();
  void set_allocated_column_def(::pg_query::ColumnDef* value);
  void unsafe_arena_set_allocated_column_def(::pg_query::ColumnDef* value);
  ::pg_query::ColumnDef* unsafe_arena_release_column_def();

  private:
  const ::pg_query::ColumnDef& _internal_column_def() const;
  ::pg_query::ColumnDef* _internal_mutable_column_def();

  public:
  // .pg_query.TableLikeClause table_like_clause = 79 [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;
  PROTOBUF_NODISCARD ::pg_query::TableLikeClause* release_table_like_clause();
  ::pg_query::TableLikeClause* mutable_table_like_clause();
  void set_allocated_table_like_clause(::pg_query::TableLikeClause* value);
  void unsafe_arena_set_allocated_table_like_clause(::pg_query::TableLikeClause* value);
  ::pg_query::TableLikeClause* unsafe_arena_release_table_like_clause();

  private:
  const ::pg_query::TableLikeClause& _internal_table_like_clause() const;
  ::pg_query::TableLikeClause* _internal_mutable_table_like_clause();

  public:
  // .pg_query.IndexElem index_elem = 80 [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;
  PROTOBUF_NODISCARD ::pg_query::IndexElem* release_index_elem();
  ::pg_query::IndexElem* mutable_index_elem();
  void set_allocated_index_elem(::pg_query::IndexElem* value);
  void unsafe_arena_set_allocated_index_elem(::pg_query::IndexElem* value);
  ::pg_query::IndexElem* unsafe_arena_release_index_elem();

  private:
  const ::pg_query::IndexElem& _internal_index_elem() const;
  ::pg_query::IndexElem* _internal_mutable_index_elem();

  public:
  // .pg_query.DefElem def_elem = 81 [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;
  PROTOBUF_NODISCARD ::pg_query::DefElem* release_def_elem();
  ::pg_query::DefElem* mutable_def_elem();
  void set_allocated_def_elem(::pg_query::DefElem* value);
  void unsafe_arena_set_allocated_def_elem(::pg_query::DefElem* value);
  ::pg_query::DefElem* unsafe_arena_release_def_elem();

  private:
  const ::pg_query::DefElem& _internal_def_elem() const;
  ::pg_query::DefElem* _internal_mutable_def_elem();

  public:
  // .pg_query.LockingClause locking_clause = 82 [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;
  PROTOBUF_NODISCARD ::pg_query::LockingClause* release_locking_clause();
  ::pg_query::LockingClause* mutable_locking_clause();
  void set_allocated_locking_clause(::pg_query::LockingClause* value);
  void unsafe_arena_set_allocated_locking_clause(::pg_query::LockingClause* value);
  ::pg_query::LockingClause* unsafe_arena_release_locking_clause();

  private:
  const ::pg_query::LockingClause& _internal_locking_clause() const;
  ::pg_query::LockingClause* _internal_mutable_locking_clause();

  public:
  // .pg_query.XmlSerialize xml_serialize = 83 [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;
  PROTOBUF_NODISCARD ::pg_query::XmlSerialize* release_xml_serialize();
  ::pg_query::XmlSerialize* mutable_xml_serialize();
  void set_allocated_xml_serialize(::pg_query::XmlSerialize* value);
  void unsafe_arena_set_allocated_xml_serialize(::pg_query::XmlSerialize* value);
  ::pg_query::XmlSerialize* unsafe_arena_release_xml_serialize();

  private:
  const ::pg_query::XmlSerialize& _internal_xml_serialize() const;
  ::pg_query::XmlSerialize* _internal_mutable_xml_serialize();

  public:
  // .pg_query.PartitionElem partition_elem = 84 [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;
  PROTOBUF_NODISCARD ::pg_query::PartitionElem* release_partition_elem();
  ::pg_query::PartitionElem* mutable_partition_elem();
  void set_allocated_partition_elem(::pg_query::PartitionElem* value);
  void unsafe_arena_set_allocated_partition_elem(::pg_query::PartitionElem* value);
  ::pg_query::PartitionElem* unsafe_arena_release_partition_elem();

  private:
  const ::pg_query::PartitionElem& _internal_partition_elem() const;
  ::pg_query::PartitionElem* _internal_mutable_partition_elem();

  public:
  // .pg_query.PartitionSpec partition_spec = 85 [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;
  PROTOBUF_NODISCARD ::pg_query::PartitionSpec* release_partition_spec();
  ::pg_query::PartitionSpec* mutable_partition_spec();
  void set_allocated_partition_spec(::pg_query::PartitionSpec* value);
  void unsafe_arena_set_allocated_partition_spec(::pg_query::PartitionSpec* value);
  ::pg_query::PartitionSpec* unsafe_arena_release_partition_spec();

  private:
  const ::pg_query::PartitionSpec& _internal_partition_spec() const;
  ::pg_query::PartitionSpec* _internal_mutable_partition_spec();

  public:
  // .pg_query.PartitionBoundSpec partition_bound_spec = 86 [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;
  PROTOBUF_NODISCARD ::pg_query::PartitionBoundSpec* release_partition_bound_spec();
  ::pg_query::PartitionBoundSpec* mutable_partition_bound_spec();
  void set_allocated_partition_bound_spec(::pg_query::PartitionBoundSpec* value);
  void unsafe_arena_set_allocated_partition_bound_spec(::pg_query::PartitionBoundSpec* value);
  ::pg_query::PartitionBoundSpec* unsafe_arena_release_partition_bound_spec();

  private:
  const ::pg_query::PartitionBoundSpec& _internal_partition_bound_spec() const;
  ::pg_query::PartitionBoundSpec* _internal_mutable_partition_bound_spec();

  public:
  // .pg_query.PartitionRangeDatum partition_range_datum = 87 [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;
  PROTOBUF_NODISCARD ::pg_query::PartitionRangeDatum* release_partition_range_datum();
  ::pg_query::PartitionRangeDatum* mutable_partition_range_datum();
  void set_allocated_partition_range_datum(::pg_query::PartitionRangeDatum* value);
  void unsafe_arena_set_allocated_partition_range_datum(::pg_query::PartitionRangeDatum* value);
  ::pg_query::PartitionRangeDatum* unsafe_arena_release_partition_range_datum();

  private:
  const ::pg_query::PartitionRangeDatum& _internal_partition_range_datum() const;
  ::pg_query::PartitionRangeDatum* _internal_mutable_partition_range_datum();

  public:
  // .pg_query.PartitionCmd partition_cmd = 88 [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;
  PROTOBUF_NODISCARD ::pg_query::PartitionCmd* release_partition_cmd();
  ::pg_query::PartitionCmd* mutable_partition_cmd();
  void set_allocated_partition_cmd(::pg_query::PartitionCmd* value);
  void unsafe_arena_set_allocated_partition_cmd(::pg_query::PartitionCmd* value);
  ::pg_query::PartitionCmd* unsafe_arena_release_partition_cmd();

  private:
  const ::pg_query::PartitionCmd& _internal_partition_cmd() const;
  ::pg_query::PartitionCmd* _internal_mutable_partition_cmd();

  public:
  // .pg_query.RangeTblEntry range_tbl_entry = 89 [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;
  PROTOBUF_NODISCARD ::pg_query::RangeTblEntry* release_range_tbl_entry();
  ::pg_query::RangeTblEntry* mutable_range_tbl_entry();
  void set_allocated_range_tbl_entry(::pg_query::RangeTblEntry* value);
  void unsafe_arena_set_allocated_range_tbl_entry(::pg_query::RangeTblEntry* value);
  ::pg_query::RangeTblEntry* unsafe_arena_release_range_tbl_entry();

  private:
  const ::pg_query::RangeTblEntry& _internal_range_tbl_entry() const;
  ::pg_query::RangeTblEntry* _internal_mutable_range_tbl_entry();

  public:
  // .pg_query.RTEPermissionInfo rtepermission_info = 90 [json_name = "RTEPermissionInfo"];
  bool has_rtepermission_info() const;
  private:
  bool _internal_has_rtepermission_info() const;

  public:
  void clear_rtepermission_info() ;
  const ::pg_query::RTEPermissionInfo& rtepermission_info() const;
  PROTOBUF_NODISCARD ::pg_query::RTEPermissionInfo* release_rtepermission_info();
  ::pg_query::RTEPermissionInfo* mutable_rtepermission_info();
  void set_allocated_rtepermission_info(::pg_query::RTEPermissionInfo* value);
  void unsafe_arena_set_allocated_rtepermission_info(::pg_query::RTEPermissionInfo* value);
  ::pg_query::RTEPermissionInfo* unsafe_arena_release_rtepermission_info();

  private:
  const ::pg_query::RTEPermissionInfo& _internal_rtepermission_info() const;
  ::pg_query::RTEPermissionInfo* _internal_mutable_rtepermission_info();

  public:
  // .pg_query.RangeTblFunction range_tbl_function = 91 [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;
  PROTOBUF_NODISCARD ::pg_query::RangeTblFunction* release_range_tbl_function();
  ::pg_query::RangeTblFunction* mutable_range_tbl_function();
  void set_allocated_range_tbl_function(::pg_query::RangeTblFunction* value);
  void unsafe_arena_set_allocated_range_tbl_function(::pg_query::RangeTblFunction* value);
  ::pg_query::RangeTblFunction* unsafe_arena_release_range_tbl_function();

  private:
  const ::pg_query::RangeTblFunction& _internal_range_tbl_function() const;
  ::pg_query::RangeTblFunction* _internal_mutable_range_tbl_function();

  public:
  // .pg_query.TableSampleClause table_sample_clause = 92 [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;
  PROTOBUF_NODISCARD ::pg_query::TableSampleClause* release_table_sample_clause();
  ::pg_query::TableSampleClause* mutable_table_sample_clause();
  void set_allocated_table_sample_clause(::pg_query::TableSampleClause* value);
  void unsafe_arena_set_allocated_table_sample_clause(::pg_query::TableSampleClause* value);
  ::pg_query::TableSampleClause* unsafe_arena_release_table_sample_clause();

  private:
  const ::pg_query::TableSampleClause& _internal_table_sample_clause() const;
  ::pg_query::TableSampleClause* _internal_mutable_table_sample_clause();

  public:
  // .pg_query.WithCheckOption with_check_option = 93 [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;
  PROTOBUF_NODISCARD ::pg_query::WithCheckOption* release_with_check_option();
  ::pg_query::WithCheckOption* mutable_with_check_option();
  void set_allocated_with_check_option(::pg_query::WithCheckOption* value);
  void unsafe_arena_set_allocated_with_check_option(::pg_query::WithCheckOption* value);
  ::pg_query::WithCheckOption* unsafe_arena_release_with_check_option();

  private:
  const ::pg_query::WithCheckOption& _internal_with_check_option() const;
  ::pg_query::WithCheckOption* _internal_mutable_with_check_option();

  public:
  // .pg_query.SortGroupClause sort_group_clause = 94 [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;
  PROTOBUF_NODISCARD ::pg_query::SortGroupClause* release_sort_group_clause();
  ::pg_query::SortGroupClause* mutable_sort_group_clause();
  void set_allocated_sort_group_clause(::pg_query::SortGroupClause* value);
  void unsafe_arena_set_allocated_sort_group_clause(::pg_query::SortGroupClause* value);
  ::pg_query::SortGroupClause* unsafe_arena_release_sort_group_clause();

  private:
  const ::pg_query::SortGroupClause& _internal_sort_group_clause() const;
  ::pg_query::SortGroupClause* _internal_mutable_sort_group_clause();

  public:
  // .pg_query.GroupingSet grouping_set = 95 [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;
  PROTOBUF_NODISCARD ::pg_query::GroupingSet* release_grouping_set();
  ::pg_query::GroupingSet* mutable_grouping_set();
  void set_allocated_grouping_set(::pg_query::GroupingSet* value);
  void unsafe_arena_set_allocated_grouping_set(::pg_query::GroupingSet* value);
  ::pg_query::GroupingSet* unsafe_arena_release_grouping_set();

  private:
  const ::pg_query::GroupingSet& _internal_grouping_set() const;
  ::pg_query::GroupingSet* _internal_mutable_grouping_set();

  public:
  // .pg_query.WindowClause window_clause = 96 [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;
  PROTOBUF_NODISCARD ::pg_query::WindowClause* release_window_clause();
  ::pg_query::WindowClause* mutable_window_clause();
  void set_allocated_window_clause(::pg_query::WindowClause* value);
  void unsafe_arena_set_allocated_window_clause(::pg_query::WindowClause* value);
  ::pg_query::WindowClause* unsafe_arena_release_window_clause();

  private:
  const ::pg_query::WindowClause& _internal_window_clause() const;
  ::pg_query::WindowClause* _internal_mutable_window_clause();

  public:
  // .pg_query.RowMarkClause row_mark_clause = 97 [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;
  PROTOBUF_NODISCARD ::pg_query::RowMarkClause* release_row_mark_clause();
  ::pg_query::RowMarkClause* mutable_row_mark_clause();
  void set_allocated_row_mark_clause(::pg_query::RowMarkClause* value);
  void unsafe_arena_set_allocated_row_mark_clause(::pg_query::RowMarkClause* value);
  ::pg_query::RowMarkClause* unsafe_arena_release_row_mark_clause();

  private:
  const ::pg_query::RowMarkClause& _internal_row_mark_clause() const;
  ::pg_query::RowMarkClause* _internal_mutable_row_mark_clause();

  public:
  // .pg_query.WithClause with_clause = 98 [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;
  PROTOBUF_NODISCARD ::pg_query::WithClause* release_with_clause();
  ::pg_query::WithClause* mutable_with_clause();
  void set_allocated_with_clause(::pg_query::WithClause* value);
  void unsafe_arena_set_allocated_with_clause(::pg_query::WithClause* value);
  ::pg_query::WithClause* unsafe_arena_release_with_clause();

  private:
  const ::pg_query::WithClause& _internal_with_clause() const;
  ::pg_query::WithClause* _internal_mutable_with_clause();

  public:
  // .pg_query.InferClause infer_clause = 99 [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;
  PROTOBUF_NODISCARD ::pg_query::InferClause* release_infer_clause();
  ::pg_query::InferClause* mutable_infer_clause();
  void set_allocated_infer_clause(::pg_query::InferClause* value);
  void unsafe_arena_set_allocated_infer_clause(::pg_query::InferClause* value);
  ::pg_query::InferClause* unsafe_arena_release_infer_clause();

  private:
  const ::pg_query::InferClause& _internal_infer_clause() const;
  ::pg_query::InferClause* _internal_mutable_infer_clause();

  public:
  // .pg_query.OnConflictClause on_conflict_clause = 100 [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;
  PROTOBUF_NODISCARD ::pg_query::OnConflictClause* release_on_conflict_clause();
  ::pg_query::OnConflictClause* mutable_on_conflict_clause();
  void set_allocated_on_conflict_clause(::pg_query::OnConflictClause* value);
  void unsafe_arena_set_allocated_on_conflict_clause(::pg_query::OnConflictClause* value);
  ::pg_query::OnConflictClause* unsafe_arena_release_on_conflict_clause();

  private:
  const ::pg_query::OnConflictClause& _internal_on_conflict_clause() const;
  ::pg_query::OnConflictClause* _internal_mutable_on_conflict_clause();

  public:
  // .pg_query.CTESearchClause ctesearch_clause = 101 [json_name = "CTESearchClause"];
  bool has_ctesearch_clause() const;
  private:
  bool _internal_has_ctesearch_clause() const;

  public:
  void clear_ctesearch_clause() ;
  const ::pg_query::CTESearchClause& ctesearch_clause() const;
  PROTOBUF_NODISCARD ::pg_query::CTESearchClause* release_ctesearch_clause();
  ::pg_query::CTESearchClause* mutable_ctesearch_clause();
  void set_allocated_ctesearch_clause(::pg_query::CTESearchClause* value);
  void unsafe_arena_set_allocated_ctesearch_clause(::pg_query::CTESearchClause* value);
  ::pg_query::CTESearchClause* unsafe_arena_release_ctesearch_clause();

  private:
  const ::pg_query::CTESearchClause& _internal_ctesearch_clause() const;
  ::pg_query::CTESearchClause* _internal_mutable_ctesearch_clause();

  public:
  // .pg_query.CTECycleClause ctecycle_clause = 102 [json_name = "CTECycleClause"];
  bool has_ctecycle_clause() const;
  private:
  bool _internal_has_ctecycle_clause() const;

  public:
  void clear_ctecycle_clause() ;
  const ::pg_query::CTECycleClause& ctecycle_clause() const;
  PROTOBUF_NODISCARD ::pg_query::CTECycleClause* release_ctecycle_clause();
  ::pg_query::CTECycleClause* mutable_ctecycle_clause();
  void set_allocated_ctecycle_clause(::pg_query::CTECycleClause* value);
  void unsafe_arena_set_allocated_ctecycle_clause(::pg_query::CTECycleClause* value);
  ::pg_query::CTECycleClause* unsafe_arena_release_ctecycle_clause();

  private:
  const ::pg_query::CTECycleClause& _internal_ctecycle_clause() const;
  ::pg_query::CTECycleClause* _internal_mutable_ctecycle_clause();

  public:
  // .pg_query.CommonTableExpr common_table_expr = 103 [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;
  PROTOBUF_NODISCARD ::pg_query::CommonTableExpr* release_common_table_expr();
  ::pg_query::CommonTableExpr* mutable_common_table_expr();
  void set_allocated_common_table_expr(::pg_query::CommonTableExpr* value);
  void unsafe_arena_set_allocated_common_table_expr(::pg_query::CommonTableExpr* value);
  ::pg_query::CommonTableExpr* unsafe_arena_release_common_table_expr();

  private:
  const ::pg_query::CommonTableExpr& _internal_common_table_expr() const;
  ::pg_query::CommonTableExpr* _internal_mutable_common_table_expr();

  public:
  // .pg_query.MergeWhenClause merge_when_clause = 104 [json_name = "MergeWhenClause"];
  bool has_merge_when_clause() const;
  private:
  bool _internal_has_merge_when_clause() const;

  public:
  void clear_merge_when_clause() ;
  const ::pg_query::MergeWhenClause& merge_when_clause() const;
  PROTOBUF_NODISCARD ::pg_query::MergeWhenClause* release_merge_when_clause();
  ::pg_query::MergeWhenClause* mutable_merge_when_clause();
  void set_allocated_merge_when_clause(::pg_query::MergeWhenClause* value);
  void unsafe_arena_set_allocated_merge_when_clause(::pg_query::MergeWhenClause* value);
  ::pg_query::MergeWhenClause* unsafe_arena_release_merge_when_clause();

  private:
  const ::pg_query::MergeWhenClause& _internal_merge_when_clause() const;
  ::pg_query::MergeWhenClause* _internal_mutable_merge_when_clause();

  public:
  // .pg_query.MergeAction merge_action = 105 [json_name = "MergeAction"];
  bool has_merge_action() const;
  private:
  bool _internal_has_merge_action() const;

  public:
  void clear_merge_action() ;
  const ::pg_query::MergeAction& merge_action() const;
  PROTOBUF_NODISCARD ::pg_query::MergeAction* release_merge_action();
  ::pg_query::MergeAction* mutable_merge_action();
  void set_allocated_merge_action(::pg_query::MergeAction* value);
  void unsafe_arena_set_allocated_merge_action(::pg_query::MergeAction* value);
  ::pg_query::MergeAction* unsafe_arena_release_merge_action();

  private:
  const ::pg_query::MergeAction& _internal_merge_action() const;
  ::pg_query::MergeAction* _internal_mutable_merge_action();

  public:
  // .pg_query.TriggerTransition trigger_transition = 106 [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;
  PROTOBUF_NODISCARD ::pg_query::TriggerTransition* release_trigger_transition();
  ::pg_query::TriggerTransition* mutable_trigger_transition();
  void set_allocated_trigger_transition(::pg_query::TriggerTransition* value);
  void unsafe_arena_set_allocated_trigger_transition(::pg_query::TriggerTransition* value);
  ::pg_query::TriggerTransition* unsafe_arena_release_trigger_transition();

  private:
  const ::pg_query::TriggerTransition& _internal_trigger_transition() const;
  ::pg_query::TriggerTransition* _internal_mutable_trigger_transition();

  public:
  // .pg_query.JsonOutput json_output = 107 [json_name = "JsonOutput"];
  bool has_json_output() const;
  private:
  bool _internal_has_json_output() const;

  public:
  void clear_json_output() ;
  const ::pg_query::JsonOutput& json_output() const;
  PROTOBUF_NODISCARD ::pg_query::JsonOutput* release_json_output();
  ::pg_query::JsonOutput* mutable_json_output();
  void set_allocated_json_output(::pg_query::JsonOutput* value);
  void unsafe_arena_set_allocated_json_output(::pg_query::JsonOutput* value);
  ::pg_query::JsonOutput* unsafe_arena_release_json_output();

  private:
  const ::pg_query::JsonOutput& _internal_json_output() const;
  ::pg_query::JsonOutput* _internal_mutable_json_output();

  public:
  // .pg_query.JsonKeyValue json_key_value = 108 [json_name = "JsonKeyValue"];
  bool has_json_key_value() const;
  private:
  bool _internal_has_json_key_value() const;

  public:
  void clear_json_key_value() ;
  const ::pg_query::JsonKeyValue& json_key_value() const;
  PROTOBUF_NODISCARD ::pg_query::JsonKeyValue* release_json_key_value();
  ::pg_query::JsonKeyValue* mutable_json_key_value();
  void set_allocated_json_key_value(::pg_query::JsonKeyValue* value);
  void unsafe_arena_set_allocated_json_key_value(::pg_query::JsonKeyValue* value);
  ::pg_query::JsonKeyValue* unsafe_arena_release_json_key_value();

  private:
  const ::pg_query::JsonKeyValue& _internal_json_key_value() const;
  ::pg_query::JsonKeyValue* _internal_mutable_json_key_value();

  public:
  // .pg_query.JsonObjectConstructor json_object_constructor = 109 [json_name = "JsonObjectConstructor"];
  bool has_json_object_constructor() const;
  private:
  bool _internal_has_json_object_constructor() const;

  public:
  void clear_json_object_constructor() ;
  const ::pg_query::JsonObjectConstructor& json_object_constructor() const;
  PROTOBUF_NODISCARD ::pg_query::JsonObjectConstructor* release_json_object_constructor();
  ::pg_query::JsonObjectConstructor* mutable_json_object_constructor();
  void set_allocated_json_object_constructor(::pg_query::JsonObjectConstructor* value);
  void unsafe_arena_set_allocated_json_object_constructor(::pg_query::JsonObjectConstructor* value);
  ::pg_query::JsonObjectConstructor* unsafe_arena_release_json_object_constructor();

  private:
  const ::pg_query::JsonObjectConstructor& _internal_json_object_constructor() const;
  ::pg_query::JsonObjectConstructor* _internal_mutable_json_object_constructor();

  public:
  // .pg_query.JsonArrayConstructor json_array_constructor = 110 [json_name = "JsonArrayConstructor"];
  bool has_json_array_constructor() const;
  private:
  bool _internal_has_json_array_constructor() const;

  public:
  void clear_json_array_constructor() ;
  const ::pg_query::JsonArrayConstructor& json_array_constructor() const;
  PROTOBUF_NODISCARD ::pg_query::JsonArrayConstructor* release_json_array_constructor();
  ::pg_query::JsonArrayConstructor* mutable_json_array_constructor();
  void set_allocated_json_array_constructor(::pg_query::JsonArrayConstructor* value);
  void unsafe_arena_set_allocated_json_array_constructor(::pg_query::JsonArrayConstructor* value);
  ::pg_query::JsonArrayConstructor* unsafe_arena_release_json_array_constructor();

  private:
  const ::pg_query::JsonArrayConstructor& _internal_json_array_constructor() const;
  ::pg_query::JsonArrayConstructor* _internal_mutable_json_array_constructor();

  public:
  // .pg_query.JsonArrayQueryConstructor json_array_query_constructor = 111 [json_name = "JsonArrayQueryConstructor"];
  bool has_json_array_query_constructor() const;
  private:
  bool _internal_has_json_array_query_constructor() const;

  public:
  void clear_json_array_query_constructor() ;
  const ::pg_query::JsonArrayQueryConstructor& json_array_query_constructor() const;
  PROTOBUF_NODISCARD ::pg_query::JsonArrayQueryConstructor* release_json_array_query_constructor();
  ::pg_query::JsonArrayQueryConstructor* mutable_json_array_query_constructor();
  void set_allocated_json_array_query_constructor(::pg_query::JsonArrayQueryConstructor* value);
  void unsafe_arena_set_allocated_json_array_query_constructor(::pg_query::JsonArrayQueryConstructor* value);
  ::pg_query::JsonArrayQueryConstructor* unsafe_arena_release_json_array_query_constructor();

  private:
  const ::pg_query::JsonArrayQueryConstructor& _internal_json_array_query_constructor() const;
  ::pg_query::JsonArrayQueryConstructor* _internal_mutable_json_array_query_constructor();

  public:
  // .pg_query.JsonAggConstructor json_agg_constructor = 112 [json_name = "JsonAggConstructor"];
  bool has_json_agg_constructor() const;
  private:
  bool _internal_has_json_agg_constructor() const;

  public:
  void clear_json_agg_constructor() ;
  const ::pg_query::JsonAggConstructor& json_agg_constructor() const;
  PROTOBUF_NODISCARD ::pg_query::JsonAggConstructor* release_json_agg_constructor();
  ::pg_query::JsonAggConstructor* mutable_json_agg_constructor();
  void set_allocated_json_agg_constructor(::pg_query::JsonAggConstructor* value);
  void unsafe_arena_set_allocated_json_agg_constructor(::pg_query::JsonAggConstructor* value);
  ::pg_query::JsonAggConstructor* unsafe_arena_release_json_agg_constructor();

  private:
  const ::pg_query::JsonAggConstructor& _internal_json_agg_constructor() const;
  ::pg_query::JsonAggConstructor* _internal_mutable_json_agg_constructor();

  public:
  // .pg_query.JsonObjectAgg json_object_agg = 113 [json_name = "JsonObjectAgg"];
  bool has_json_object_agg() const;
  private:
  bool _internal_has_json_object_agg() const;

  public:
  void clear_json_object_agg() ;
  const ::pg_query::JsonObjectAgg& json_object_agg() const;
  PROTOBUF_NODISCARD ::pg_query::JsonObjectAgg* release_json_object_agg();
  ::pg_query::JsonObjectAgg* mutable_json_object_agg();
  void set_allocated_json_object_agg(::pg_query::JsonObjectAgg* value);
  void unsafe_arena_set_allocated_json_object_agg(::pg_query::JsonObjectAgg* value);
  ::pg_query::JsonObjectAgg* unsafe_arena_release_json_object_agg();

  private:
  const ::pg_query::JsonObjectAgg& _internal_json_object_agg() const;
  ::pg_query::JsonObjectAgg* _internal_mutable_json_object_agg();

  public:
  // .pg_query.JsonArrayAgg json_array_agg = 114 [json_name = "JsonArrayAgg"];
  bool has_json_array_agg() const;
  private:
  bool _internal_has_json_array_agg() const;

  public:
  void clear_json_array_agg() ;
  const ::pg_query::JsonArrayAgg& json_array_agg() const;
  PROTOBUF_NODISCARD ::pg_query::JsonArrayAgg* release_json_array_agg();
  ::pg_query::JsonArrayAgg* mutable_json_array_agg();
  void set_allocated_json_array_agg(::pg_query::JsonArrayAgg* value);
  void unsafe_arena_set_allocated_json_array_agg(::pg_query::JsonArrayAgg* value);
  ::pg_query::JsonArrayAgg* unsafe_arena_release_json_array_agg();

  private:
  const ::pg_query::JsonArrayAgg& _internal_json_array_agg() const;
  ::pg_query::JsonArrayAgg* _internal_mutable_json_array_agg();

  public:
  // .pg_query.RawStmt raw_stmt = 115 [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;
  PROTOBUF_NODISCARD ::pg_query::RawStmt* release_raw_stmt();
  ::pg_query::RawStmt* mutable_raw_stmt();
  void set_allocated_raw_stmt(::pg_query::RawStmt* value);
  void unsafe_arena_set_allocated_raw_stmt(::pg_query::RawStmt* value);
  ::pg_query::RawStmt* unsafe_arena_release_raw_stmt();

  private:
  const ::pg_query::RawStmt& _internal_raw_stmt() const;
  ::pg_query::RawStmt* _internal_mutable_raw_stmt();

  public:
  // .pg_query.InsertStmt insert_stmt = 116 [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;
  PROTOBUF_NODISCARD ::pg_query::InsertStmt* release_insert_stmt();
  ::pg_query::InsertStmt* mutable_insert_stmt();
  void set_allocated_insert_stmt(::pg_query::InsertStmt* value);
  void unsafe_arena_set_allocated_insert_stmt(::pg_query::InsertStmt* value);
  ::pg_query::InsertStmt* unsafe_arena_release_insert_stmt();

  private:
  const ::pg_query::InsertStmt& _internal_insert_stmt() const;
  ::pg_query::InsertStmt* _internal_mutable_insert_stmt();

  public:
  // .pg_query.DeleteStmt delete_stmt = 117 [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;
  PROTOBUF_NODISCARD ::pg_query::DeleteStmt* release_delete_stmt();
  ::pg_query::DeleteStmt* mutable_delete_stmt();
  void set_allocated_delete_stmt(::pg_query::DeleteStmt* value);
  void unsafe_arena_set_allocated_delete_stmt(::pg_query::DeleteStmt* value);
  ::pg_query::DeleteStmt* unsafe_arena_release_delete_stmt();

  private:
  const ::pg_query::DeleteStmt& _internal_delete_stmt() const;
  ::pg_query::DeleteStmt* _internal_mutable_delete_stmt();

  public:
  // .pg_query.UpdateStmt update_stmt = 118 [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;
  PROTOBUF_NODISCARD ::pg_query::UpdateStmt* release_update_stmt();
  ::pg_query::UpdateStmt* mutable_update_stmt();
  void set_allocated_update_stmt(::pg_query::UpdateStmt* value);
  void unsafe_arena_set_allocated_update_stmt(::pg_query::UpdateStmt* value);
  ::pg_query::UpdateStmt* unsafe_arena_release_update_stmt();

  private:
  const ::pg_query::UpdateStmt& _internal_update_stmt() const;
  ::pg_query::UpdateStmt* _internal_mutable_update_stmt();

  public:
  // .pg_query.MergeStmt merge_stmt = 119 [json_name = "MergeStmt"];
  bool has_merge_stmt() const;
  private:
  bool _internal_has_merge_stmt() const;

  public:
  void clear_merge_stmt() ;
  const ::pg_query::MergeStmt& merge_stmt() const;
  PROTOBUF_NODISCARD ::pg_query::MergeStmt* release_merge_stmt();
  ::pg_query::MergeStmt* mutable_merge_stmt();
  void set_allocated_merge_stmt(::pg_query::MergeStmt* value);
  void unsafe_arena_set_allocated_merge_stmt(::pg_query::MergeStmt* value);
  ::pg_query::MergeStmt* unsafe_arena_release_merge_stmt();

  private:
  const ::pg_query::MergeStmt& _internal_merge_stmt() const;
  ::pg_query::MergeStmt* _internal_mutable_merge_stmt();

  public:
  // .pg_query.SelectStmt select_stmt = 120 [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;
  PROTOBUF_NODISCARD ::pg_query::SelectStmt* release_select_stmt();
  ::pg_query::SelectStmt* mutable_select_stmt();
  void set_allocated_select_stmt(::pg_query::SelectStmt* value);
  void unsafe_arena_set_allocated_select_stmt(::pg_query::SelectStmt* value);
  ::pg_query::SelectStmt* unsafe_arena_release_select_stmt();

  private:
  const ::pg_query::SelectStmt& _internal_select_stmt() const;
  ::pg_query::SelectStmt* _internal_mutable_select_stmt();

  public:
  // .pg_query.SetOperationStmt set_operation_stmt = 121 [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;
  PROTOBUF_NODISCARD ::pg_query::SetOperationStmt* release_set_operation_stmt();
  ::pg_query::SetOperationStmt* mutable_set_operation_stmt();
  void set_allocated_set_operation_stmt(::pg_query::SetOperationStmt* value);
  void unsafe_arena_set_allocated_set_operation_stmt(::pg_query::SetOperationStmt* value);
  ::pg_query::SetOperationStmt* unsafe_arena_release_set_operation_stmt();

  private:
  const ::pg_query::SetOperationStmt& _internal_set_operation_stmt() const;
  ::pg_query::SetOperationStmt* _internal_mutable_set_operation_stmt();

  public:
  // .pg_query.ReturnStmt return_stmt = 122 [json_name = "ReturnStmt"];
  bool has_return_stmt() const;
  private:
  bool _internal_has_return_stmt() const;

  public:
  void clear_return_stmt() ;
  const ::pg_query::ReturnStmt& return_stmt() const;
  PROTOBUF_NODISCARD ::pg_query::ReturnStmt* release_return_stmt();
  ::pg_query::ReturnStmt* mutable_return_stmt();
  void set_allocated_return_stmt(::pg_query::ReturnStmt* value);
  void unsafe_arena_set_allocated_return_stmt(::pg_query::ReturnStmt* value);
  ::pg_query::ReturnStmt* unsafe_arena_release_return_stmt();

  private:
  const ::pg_query::ReturnStmt& _internal_return_stmt() const;
  ::pg_query::ReturnStmt* _internal_mutable_return_stmt();

  public:
  // .pg_query.PLAssignStmt plassign_stmt = 123 [json_name = "PLAssignStmt"];
  bool has_plassign_stmt() const;
  private:
  bool _internal_has_plassign_stmt() const;

  public:
  void clear_plassign_stmt() ;
  const ::pg_query::PLAssignStmt& plassign_stmt() const;
  PROTOBUF_NODISCARD ::pg_query::PLAssignStmt* release_plassign_stmt();
  ::pg_query::PLAssignStmt* mutable_plassign_stmt();
  void set_allocated_plassign_stmt(::pg_query::PLAssignStmt* value);
  void unsafe_arena_set_allocated_plassign_stmt(::pg_query::PLAssignStmt* value);
  ::pg_query::PLAssignStmt* unsafe_arena_release_plassign_stmt();

  private:
  const ::pg_query::PLAssignStmt& _internal_plassign_stmt() const;
  ::pg_query::PLAssignStmt* _internal_mutable_plassign_stmt();

  public:
  // .pg_query.CreateSchemaStmt create_schema_stmt = 124 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateSchemaStmt* release_create_schema_stmt();
  ::pg_query::CreateSchemaStmt* mutable_create_schema_stmt();
  void set_allocated_create_schema_stmt(::pg_query::CreateSchemaStmt* value);
  void unsafe_arena_set_allocated_create_schema_stmt(::pg_query::CreateSchemaStmt* value);
  ::pg_query::CreateSchemaStmt* unsafe_arena_release_create_schema_stmt();

  private:
  const ::pg_query::CreateSchemaStmt& _internal_create_schema_stmt() const;
  ::pg_query::CreateSchemaStmt* _internal_mutable_create_schema_stmt();

  public:
  // .pg_query.AlterTableStmt alter_table_stmt = 125 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterTableStmt* release_alter_table_stmt();
  ::pg_query::AlterTableStmt* mutable_alter_table_stmt();
  void set_allocated_alter_table_stmt(::pg_query::AlterTableStmt* value);
  void unsafe_arena_set_allocated_alter_table_stmt(::pg_query::AlterTableStmt* value);
  ::pg_query::AlterTableStmt* unsafe_arena_release_alter_table_stmt();

  private:
  const ::pg_query::AlterTableStmt& _internal_alter_table_stmt() const;
  ::pg_query::AlterTableStmt* _internal_mutable_alter_table_stmt();

  public:
  // .pg_query.ReplicaIdentityStmt replica_identity_stmt = 126 [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;
  PROTOBUF_NODISCARD ::pg_query::ReplicaIdentityStmt* release_replica_identity_stmt();
  ::pg_query::ReplicaIdentityStmt* mutable_replica_identity_stmt();
  void set_allocated_replica_identity_stmt(::pg_query::ReplicaIdentityStmt* value);
  void unsafe_arena_set_allocated_replica_identity_stmt(::pg_query::ReplicaIdentityStmt* value);
  ::pg_query::ReplicaIdentityStmt* unsafe_arena_release_replica_identity_stmt();

  private:
  const ::pg_query::ReplicaIdentityStmt& _internal_replica_identity_stmt() const;
  ::pg_query::ReplicaIdentityStmt* _internal_mutable_replica_identity_stmt();

  public:
  // .pg_query.AlterTableCmd alter_table_cmd = 127 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterTableCmd* release_alter_table_cmd();
  ::pg_query::AlterTableCmd* mutable_alter_table_cmd();
  void set_allocated_alter_table_cmd(::pg_query::AlterTableCmd* value);
  void unsafe_arena_set_allocated_alter_table_cmd(::pg_query::AlterTableCmd* value);
  ::pg_query::AlterTableCmd* unsafe_arena_release_alter_table_cmd();

  private:
  const ::pg_query::AlterTableCmd& _internal_alter_table_cmd() const;
  ::pg_query::AlterTableCmd* _internal_mutable_alter_table_cmd();

  public:
  // .pg_query.AlterCollationStmt alter_collation_stmt = 128 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterCollationStmt* release_alter_collation_stmt();
  ::pg_query::AlterCollationStmt* mutable_alter_collation_stmt();
  void set_allocated_alter_collation_stmt(::pg_query::AlterCollationStmt* value);
  void unsafe_arena_set_allocated_alter_collation_stmt(::pg_query::AlterCollationStmt* value);
  ::pg_query::AlterCollationStmt* unsafe_arena_release_alter_collation_stmt();

  private:
  const ::pg_query::AlterCollationStmt& _internal_alter_collation_stmt() const;
  ::pg_query::AlterCollationStmt* _internal_mutable_alter_collation_stmt();

  public:
  // .pg_query.AlterDomainStmt alter_domain_stmt = 129 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterDomainStmt* release_alter_domain_stmt();
  ::pg_query::AlterDomainStmt* mutable_alter_domain_stmt();
  void set_allocated_alter_domain_stmt(::pg_query::AlterDomainStmt* value);
  void unsafe_arena_set_allocated_alter_domain_stmt(::pg_query::AlterDomainStmt* value);
  ::pg_query::AlterDomainStmt* unsafe_arena_release_alter_domain_stmt();

  private:
  const ::pg_query::AlterDomainStmt& _internal_alter_domain_stmt() const;
  ::pg_query::AlterDomainStmt* _internal_mutable_alter_domain_stmt();

  public:
  // .pg_query.GrantStmt grant_stmt = 130 [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;
  PROTOBUF_NODISCARD ::pg_query::GrantStmt* release_grant_stmt();
  ::pg_query::GrantStmt* mutable_grant_stmt();
  void set_allocated_grant_stmt(::pg_query::GrantStmt* value);
  void unsafe_arena_set_allocated_grant_stmt(::pg_query::GrantStmt* value);
  ::pg_query::GrantStmt* unsafe_arena_release_grant_stmt();

  private:
  const ::pg_query::GrantStmt& _internal_grant_stmt() const;
  ::pg_query::GrantStmt* _internal_mutable_grant_stmt();

  public:
  // .pg_query.ObjectWithArgs object_with_args = 131 [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;
  PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_object_with_args();
  ::pg_query::ObjectWithArgs* mutable_object_with_args();
  void set_allocated_object_with_args(::pg_query::ObjectWithArgs* value);
  void unsafe_arena_set_allocated_object_with_args(::pg_query::ObjectWithArgs* value);
  ::pg_query::ObjectWithArgs* unsafe_arena_release_object_with_args();

  private:
  const ::pg_query::ObjectWithArgs& _internal_object_with_args() const;
  ::pg_query::ObjectWithArgs* _internal_mutable_object_with_args();

  public:
  // .pg_query.AccessPriv access_priv = 132 [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;
  PROTOBUF_NODISCARD ::pg_query::AccessPriv* release_access_priv();
  ::pg_query::AccessPriv* mutable_access_priv();
  void set_allocated_access_priv(::pg_query::AccessPriv* value);
  void unsafe_arena_set_allocated_access_priv(::pg_query::AccessPriv* value);
  ::pg_query::AccessPriv* unsafe_arena_release_access_priv();

  private:
  const ::pg_query::AccessPriv& _internal_access_priv() const;
  ::pg_query::AccessPriv* _internal_mutable_access_priv();

  public:
  // .pg_query.GrantRoleStmt grant_role_stmt = 133 [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;
  PROTOBUF_NODISCARD ::pg_query::GrantRoleStmt* release_grant_role_stmt();
  ::pg_query::GrantRoleStmt* mutable_grant_role_stmt();
  void set_allocated_grant_role_stmt(::pg_query::GrantRoleStmt* value);
  void unsafe_arena_set_allocated_grant_role_stmt(::pg_query::GrantRoleStmt* value);
  ::pg_query::GrantRoleStmt* unsafe_arena_release_grant_role_stmt();

  private:
  const ::pg_query::GrantRoleStmt& _internal_grant_role_stmt() const;
  ::pg_query::GrantRoleStmt* _internal_mutable_grant_role_stmt();

  public:
  // .pg_query.AlterDefaultPrivilegesStmt alter_default_privileges_stmt = 134 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_alter_default_privileges_stmt(::pg_query::AlterDefaultPrivilegesStmt* value);
  ::pg_query::AlterDefaultPrivilegesStmt* unsafe_arena_release_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:
  // .pg_query.CopyStmt copy_stmt = 135 [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;
  PROTOBUF_NODISCARD ::pg_query::CopyStmt* release_copy_stmt();
  ::pg_query::CopyStmt* mutable_copy_stmt();
  void set_allocated_copy_stmt(::pg_query::CopyStmt* value);
  void unsafe_arena_set_allocated_copy_stmt(::pg_query::CopyStmt* value);
  ::pg_query::CopyStmt* unsafe_arena_release_copy_stmt();

  private:
  const ::pg_query::CopyStmt& _internal_copy_stmt() const;
  ::pg_query::CopyStmt* _internal_mutable_copy_stmt();

  public:
  // .pg_query.VariableSetStmt variable_set_stmt = 136 [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;
  PROTOBUF_NODISCARD ::pg_query::VariableSetStmt* release_variable_set_stmt();
  ::pg_query::VariableSetStmt* mutable_variable_set_stmt();
  void set_allocated_variable_set_stmt(::pg_query::VariableSetStmt* value);
  void unsafe_arena_set_allocated_variable_set_stmt(::pg_query::VariableSetStmt* value);
  ::pg_query::VariableSetStmt* unsafe_arena_release_variable_set_stmt();

  private:
  const ::pg_query::VariableSetStmt& _internal_variable_set_stmt() const;
  ::pg_query::VariableSetStmt* _internal_mutable_variable_set_stmt();

  public:
  // .pg_query.VariableShowStmt variable_show_stmt = 137 [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;
  PROTOBUF_NODISCARD ::pg_query::VariableShowStmt* release_variable_show_stmt();
  ::pg_query::VariableShowStmt* mutable_variable_show_stmt();
  void set_allocated_variable_show_stmt(::pg_query::VariableShowStmt* value);
  void unsafe_arena_set_allocated_variable_show_stmt(::pg_query::VariableShowStmt* value);
  ::pg_query::VariableShowStmt* unsafe_arena_release_variable_show_stmt();

  private:
  const ::pg_query::VariableShowStmt& _internal_variable_show_stmt() const;
  ::pg_query::VariableShowStmt* _internal_mutable_variable_show_stmt();

  public:
  // .pg_query.CreateStmt create_stmt = 138 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateStmt* release_create_stmt();
  ::pg_query::CreateStmt* mutable_create_stmt();
  void set_allocated_create_stmt(::pg_query::CreateStmt* value);
  void unsafe_arena_set_allocated_create_stmt(::pg_query::CreateStmt* value);
  ::pg_query::CreateStmt* unsafe_arena_release_create_stmt();

  private:
  const ::pg_query::CreateStmt& _internal_create_stmt() const;
  ::pg_query::CreateStmt* _internal_mutable_create_stmt();

  public:
  // .pg_query.Constraint constraint = 139 [json_name = "Constraint"];
  bool has_constraint() const;
  private:
  bool _internal_has_constraint() const;

  public:
  void clear_constraint() ;
  const ::pg_query::Constraint& constraint() const;
  PROTOBUF_NODISCARD ::pg_query::Constraint* release_constraint();
  ::pg_query::Constraint* mutable_constraint();
  void set_allocated_constraint(::pg_query::Constraint* value);
  void unsafe_arena_set_allocated_constraint(::pg_query::Constraint* value);
  ::pg_query::Constraint* unsafe_arena_release_constraint();

  private:
  const ::pg_query::Constraint& _internal_constraint() const;
  ::pg_query::Constraint* _internal_mutable_constraint();

  public:
  // .pg_query.CreateTableSpaceStmt create_table_space_stmt = 140 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_create_table_space_stmt(::pg_query::CreateTableSpaceStmt* value);
  ::pg_query::CreateTableSpaceStmt* unsafe_arena_release_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:
  // .pg_query.DropTableSpaceStmt drop_table_space_stmt = 141 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_drop_table_space_stmt(::pg_query::DropTableSpaceStmt* value);
  ::pg_query::DropTableSpaceStmt* unsafe_arena_release_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:
  // .pg_query.AlterTableSpaceOptionsStmt alter_table_space_options_stmt = 142 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_alter_table_space_options_stmt(::pg_query::AlterTableSpaceOptionsStmt* value);
  ::pg_query::AlterTableSpaceOptionsStmt* unsafe_arena_release_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:
  // .pg_query.AlterTableMoveAllStmt alter_table_move_all_stmt = 143 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_alter_table_move_all_stmt(::pg_query::AlterTableMoveAllStmt* value);
  ::pg_query::AlterTableMoveAllStmt* unsafe_arena_release_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:
  // .pg_query.CreateExtensionStmt create_extension_stmt = 144 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateExtensionStmt* release_create_extension_stmt();
  ::pg_query::CreateExtensionStmt* mutable_create_extension_stmt();
  void set_allocated_create_extension_stmt(::pg_query::CreateExtensionStmt* value);
  void unsafe_arena_set_allocated_create_extension_stmt(::pg_query::CreateExtensionStmt* value);
  ::pg_query::CreateExtensionStmt* unsafe_arena_release_create_extension_stmt();

  private:
  const ::pg_query::CreateExtensionStmt& _internal_create_extension_stmt() const;
  ::pg_query::CreateExtensionStmt* _internal_mutable_create_extension_stmt();

  public:
  // .pg_query.AlterExtensionStmt alter_extension_stmt = 145 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterExtensionStmt* release_alter_extension_stmt();
  ::pg_query::AlterExtensionStmt* mutable_alter_extension_stmt();
  void set_allocated_alter_extension_stmt(::pg_query::AlterExtensionStmt* value);
  void unsafe_arena_set_allocated_alter_extension_stmt(::pg_query::AlterExtensionStmt* value);
  ::pg_query::AlterExtensionStmt* unsafe_arena_release_alter_extension_stmt();

  private:
  const ::pg_query::AlterExtensionStmt& _internal_alter_extension_stmt() const;
  ::pg_query::AlterExtensionStmt* _internal_mutable_alter_extension_stmt();

  public:
  // .pg_query.AlterExtensionContentsStmt alter_extension_contents_stmt = 146 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_alter_extension_contents_stmt(::pg_query::AlterExtensionContentsStmt* value);
  ::pg_query::AlterExtensionContentsStmt* unsafe_arena_release_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:
  // .pg_query.CreateFdwStmt create_fdw_stmt = 147 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateFdwStmt* release_create_fdw_stmt();
  ::pg_query::CreateFdwStmt* mutable_create_fdw_stmt();
  void set_allocated_create_fdw_stmt(::pg_query::CreateFdwStmt* value);
  void unsafe_arena_set_allocated_create_fdw_stmt(::pg_query::CreateFdwStmt* value);
  ::pg_query::CreateFdwStmt* unsafe_arena_release_create_fdw_stmt();

  private:
  const ::pg_query::CreateFdwStmt& _internal_create_fdw_stmt() const;
  ::pg_query::CreateFdwStmt* _internal_mutable_create_fdw_stmt();

  public:
  // .pg_query.AlterFdwStmt alter_fdw_stmt = 148 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterFdwStmt* release_alter_fdw_stmt();
  ::pg_query::AlterFdwStmt* mutable_alter_fdw_stmt();
  void set_allocated_alter_fdw_stmt(::pg_query::AlterFdwStmt* value);
  void unsafe_arena_set_allocated_alter_fdw_stmt(::pg_query::AlterFdwStmt* value);
  ::pg_query::AlterFdwStmt* unsafe_arena_release_alter_fdw_stmt();

  private:
  const ::pg_query::AlterFdwStmt& _internal_alter_fdw_stmt() const;
  ::pg_query::AlterFdwStmt* _internal_mutable_alter_fdw_stmt();

  public:
  // .pg_query.CreateForeignServerStmt create_foreign_server_stmt = 149 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_create_foreign_server_stmt(::pg_query::CreateForeignServerStmt* value);
  ::pg_query::CreateForeignServerStmt* unsafe_arena_release_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:
  // .pg_query.AlterForeignServerStmt alter_foreign_server_stmt = 150 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_alter_foreign_server_stmt(::pg_query::AlterForeignServerStmt* value);
  ::pg_query::AlterForeignServerStmt* unsafe_arena_release_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:
  // .pg_query.CreateForeignTableStmt create_foreign_table_stmt = 151 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_create_foreign_table_stmt(::pg_query::CreateForeignTableStmt* value);
  ::pg_query::CreateForeignTableStmt* unsafe_arena_release_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:
  // .pg_query.CreateUserMappingStmt create_user_mapping_stmt = 152 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_create_user_mapping_stmt(::pg_query::CreateUserMappingStmt* value);
  ::pg_query::CreateUserMappingStmt* unsafe_arena_release_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:
  // .pg_query.AlterUserMappingStmt alter_user_mapping_stmt = 153 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_alter_user_mapping_stmt(::pg_query::AlterUserMappingStmt* value);
  ::pg_query::AlterUserMappingStmt* unsafe_arena_release_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:
  // .pg_query.DropUserMappingStmt drop_user_mapping_stmt = 154 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_drop_user_mapping_stmt(::pg_query::DropUserMappingStmt* value);
  ::pg_query::DropUserMappingStmt* unsafe_arena_release_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:
  // .pg_query.ImportForeignSchemaStmt import_foreign_schema_stmt = 155 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_import_foreign_schema_stmt(::pg_query::ImportForeignSchemaStmt* value);
  ::pg_query::ImportForeignSchemaStmt* unsafe_arena_release_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:
  // .pg_query.CreatePolicyStmt create_policy_stmt = 156 [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;
  PROTOBUF_NODISCARD ::pg_query::CreatePolicyStmt* release_create_policy_stmt();
  ::pg_query::CreatePolicyStmt* mutable_create_policy_stmt();
  void set_allocated_create_policy_stmt(::pg_query::CreatePolicyStmt* value);
  void unsafe_arena_set_allocated_create_policy_stmt(::pg_query::CreatePolicyStmt* value);
  ::pg_query::CreatePolicyStmt* unsafe_arena_release_create_policy_stmt();

  private:
  const ::pg_query::CreatePolicyStmt& _internal_create_policy_stmt() const;
  ::pg_query::CreatePolicyStmt* _internal_mutable_create_policy_stmt();

  public:
  // .pg_query.AlterPolicyStmt alter_policy_stmt = 157 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterPolicyStmt* release_alter_policy_stmt();
  ::pg_query::AlterPolicyStmt* mutable_alter_policy_stmt();
  void set_allocated_alter_policy_stmt(::pg_query::AlterPolicyStmt* value);
  void unsafe_arena_set_allocated_alter_policy_stmt(::pg_query::AlterPolicyStmt* value);
  ::pg_query::AlterPolicyStmt* unsafe_arena_release_alter_policy_stmt();

  private:
  const ::pg_query::AlterPolicyStmt& _internal_alter_policy_stmt() const;
  ::pg_query::AlterPolicyStmt* _internal_mutable_alter_policy_stmt();

  public:
  // .pg_query.CreateAmStmt create_am_stmt = 158 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateAmStmt* release_create_am_stmt();
  ::pg_query::CreateAmStmt* mutable_create_am_stmt();
  void set_allocated_create_am_stmt(::pg_query::CreateAmStmt* value);
  void unsafe_arena_set_allocated_create_am_stmt(::pg_query::CreateAmStmt* value);
  ::pg_query::CreateAmStmt* unsafe_arena_release_create_am_stmt();

  private:
  const ::pg_query::CreateAmStmt& _internal_create_am_stmt() const;
  ::pg_query::CreateAmStmt* _internal_mutable_create_am_stmt();

  public:
  // .pg_query.CreateTrigStmt create_trig_stmt = 159 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateTrigStmt* release_create_trig_stmt();
  ::pg_query::CreateTrigStmt* mutable_create_trig_stmt();
  void set_allocated_create_trig_stmt(::pg_query::CreateTrigStmt* value);
  void unsafe_arena_set_allocated_create_trig_stmt(::pg_query::CreateTrigStmt* value);
  ::pg_query::CreateTrigStmt* unsafe_arena_release_create_trig_stmt();

  private:
  const ::pg_query::CreateTrigStmt& _internal_create_trig_stmt() const;
  ::pg_query::CreateTrigStmt* _internal_mutable_create_trig_stmt();

  public:
  // .pg_query.CreateEventTrigStmt create_event_trig_stmt = 160 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_create_event_trig_stmt(::pg_query::CreateEventTrigStmt* value);
  ::pg_query::CreateEventTrigStmt* unsafe_arena_release_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:
  // .pg_query.AlterEventTrigStmt alter_event_trig_stmt = 161 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_alter_event_trig_stmt(::pg_query::AlterEventTrigStmt* value);
  ::pg_query::AlterEventTrigStmt* unsafe_arena_release_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:
  // .pg_query.CreatePLangStmt create_plang_stmt = 162 [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;
  PROTOBUF_NODISCARD ::pg_query::CreatePLangStmt* release_create_plang_stmt();
  ::pg_query::CreatePLangStmt* mutable_create_plang_stmt();
  void set_allocated_create_plang_stmt(::pg_query::CreatePLangStmt* value);
  void unsafe_arena_set_allocated_create_plang_stmt(::pg_query::CreatePLangStmt* value);
  ::pg_query::CreatePLangStmt* unsafe_arena_release_create_plang_stmt();

  private:
  const ::pg_query::CreatePLangStmt& _internal_create_plang_stmt() const;
  ::pg_query::CreatePLangStmt* _internal_mutable_create_plang_stmt();

  public:
  // .pg_query.CreateRoleStmt create_role_stmt = 163 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateRoleStmt* release_create_role_stmt();
  ::pg_query::CreateRoleStmt* mutable_create_role_stmt();
  void set_allocated_create_role_stmt(::pg_query::CreateRoleStmt* value);
  void unsafe_arena_set_allocated_create_role_stmt(::pg_query::CreateRoleStmt* value);
  ::pg_query::CreateRoleStmt* unsafe_arena_release_create_role_stmt();

  private:
  const ::pg_query::CreateRoleStmt& _internal_create_role_stmt() const;
  ::pg_query::CreateRoleStmt* _internal_mutable_create_role_stmt();

  public:
  // .pg_query.AlterRoleStmt alter_role_stmt = 164 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterRoleStmt* release_alter_role_stmt();
  ::pg_query::AlterRoleStmt* mutable_alter_role_stmt();
  void set_allocated_alter_role_stmt(::pg_query::AlterRoleStmt* value);
  void unsafe_arena_set_allocated_alter_role_stmt(::pg_query::AlterRoleStmt* value);
  ::pg_query::AlterRoleStmt* unsafe_arena_release_alter_role_stmt();

  private:
  const ::pg_query::AlterRoleStmt& _internal_alter_role_stmt() const;
  ::pg_query::AlterRoleStmt* _internal_mutable_alter_role_stmt();

  public:
  // .pg_query.AlterRoleSetStmt alter_role_set_stmt = 165 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_alter_role_set_stmt(::pg_query::AlterRoleSetStmt* value);
  ::pg_query::AlterRoleSetStmt* unsafe_arena_release_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:
  // .pg_query.DropRoleStmt drop_role_stmt = 166 [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;
  PROTOBUF_NODISCARD ::pg_query::DropRoleStmt* release_drop_role_stmt();
  ::pg_query::DropRoleStmt* mutable_drop_role_stmt();
  void set_allocated_drop_role_stmt(::pg_query::DropRoleStmt* value);
  void unsafe_arena_set_allocated_drop_role_stmt(::pg_query::DropRoleStmt* value);
  ::pg_query::DropRoleStmt* unsafe_arena_release_drop_role_stmt();

  private:
  const ::pg_query::DropRoleStmt& _internal_drop_role_stmt() const;
  ::pg_query::DropRoleStmt* _internal_mutable_drop_role_stmt();

  public:
  // .pg_query.CreateSeqStmt create_seq_stmt = 167 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateSeqStmt* release_create_seq_stmt();
  ::pg_query::CreateSeqStmt* mutable_create_seq_stmt();
  void set_allocated_create_seq_stmt(::pg_query::CreateSeqStmt* value);
  void unsafe_arena_set_allocated_create_seq_stmt(::pg_query::CreateSeqStmt* value);
  ::pg_query::CreateSeqStmt* unsafe_arena_release_create_seq_stmt();

  private:
  const ::pg_query::CreateSeqStmt& _internal_create_seq_stmt() const;
  ::pg_query::CreateSeqStmt* _internal_mutable_create_seq_stmt();

  public:
  // .pg_query.AlterSeqStmt alter_seq_stmt = 168 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterSeqStmt* release_alter_seq_stmt();
  ::pg_query::AlterSeqStmt* mutable_alter_seq_stmt();
  void set_allocated_alter_seq_stmt(::pg_query::AlterSeqStmt* value);
  void unsafe_arena_set_allocated_alter_seq_stmt(::pg_query::AlterSeqStmt* value);
  ::pg_query::AlterSeqStmt* unsafe_arena_release_alter_seq_stmt();

  private:
  const ::pg_query::AlterSeqStmt& _internal_alter_seq_stmt() const;
  ::pg_query::AlterSeqStmt* _internal_mutable_alter_seq_stmt();

  public:
  // .pg_query.DefineStmt define_stmt = 169 [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;
  PROTOBUF_NODISCARD ::pg_query::DefineStmt* release_define_stmt();
  ::pg_query::DefineStmt* mutable_define_stmt();
  void set_allocated_define_stmt(::pg_query::DefineStmt* value);
  void unsafe_arena_set_allocated_define_stmt(::pg_query::DefineStmt* value);
  ::pg_query::DefineStmt* unsafe_arena_release_define_stmt();

  private:
  const ::pg_query::DefineStmt& _internal_define_stmt() const;
  ::pg_query::DefineStmt* _internal_mutable_define_stmt();

  public:
  // .pg_query.CreateDomainStmt create_domain_stmt = 170 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateDomainStmt* release_create_domain_stmt();
  ::pg_query::CreateDomainStmt* mutable_create_domain_stmt();
  void set_allocated_create_domain_stmt(::pg_query::CreateDomainStmt* value);
  void unsafe_arena_set_allocated_create_domain_stmt(::pg_query::CreateDomainStmt* value);
  ::pg_query::CreateDomainStmt* unsafe_arena_release_create_domain_stmt();

  private:
  const ::pg_query::CreateDomainStmt& _internal_create_domain_stmt() const;
  ::pg_query::CreateDomainStmt* _internal_mutable_create_domain_stmt();

  public:
  // .pg_query.CreateOpClassStmt create_op_class_stmt = 171 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_create_op_class_stmt(::pg_query::CreateOpClassStmt* value);
  ::pg_query::CreateOpClassStmt* unsafe_arena_release_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:
  // .pg_query.CreateOpClassItem create_op_class_item = 172 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_create_op_class_item(::pg_query::CreateOpClassItem* value);
  ::pg_query::CreateOpClassItem* unsafe_arena_release_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:
  // .pg_query.CreateOpFamilyStmt create_op_family_stmt = 173 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_create_op_family_stmt(::pg_query::CreateOpFamilyStmt* value);
  ::pg_query::CreateOpFamilyStmt* unsafe_arena_release_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:
  // .pg_query.AlterOpFamilyStmt alter_op_family_stmt = 174 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_alter_op_family_stmt(::pg_query::AlterOpFamilyStmt* value);
  ::pg_query::AlterOpFamilyStmt* unsafe_arena_release_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:
  // .pg_query.DropStmt drop_stmt = 175 [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;
  PROTOBUF_NODISCARD ::pg_query::DropStmt* release_drop_stmt();
  ::pg_query::DropStmt* mutable_drop_stmt();
  void set_allocated_drop_stmt(::pg_query::DropStmt* value);
  void unsafe_arena_set_allocated_drop_stmt(::pg_query::DropStmt* value);
  ::pg_query::DropStmt* unsafe_arena_release_drop_stmt();

  private:
  const ::pg_query::DropStmt& _internal_drop_stmt() const;
  ::pg_query::DropStmt* _internal_mutable_drop_stmt();

  public:
  // .pg_query.TruncateStmt truncate_stmt = 176 [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;
  PROTOBUF_NODISCARD ::pg_query::TruncateStmt* release_truncate_stmt();
  ::pg_query::TruncateStmt* mutable_truncate_stmt();
  void set_allocated_truncate_stmt(::pg_query::TruncateStmt* value);
  void unsafe_arena_set_allocated_truncate_stmt(::pg_query::TruncateStmt* value);
  ::pg_query::TruncateStmt* unsafe_arena_release_truncate_stmt();

  private:
  const ::pg_query::TruncateStmt& _internal_truncate_stmt() const;
  ::pg_query::TruncateStmt* _internal_mutable_truncate_stmt();

  public:
  // .pg_query.CommentStmt comment_stmt = 177 [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;
  PROTOBUF_NODISCARD ::pg_query::CommentStmt* release_comment_stmt();
  ::pg_query::CommentStmt* mutable_comment_stmt();
  void set_allocated_comment_stmt(::pg_query::CommentStmt* value);
  void unsafe_arena_set_allocated_comment_stmt(::pg_query::CommentStmt* value);
  ::pg_query::CommentStmt* unsafe_arena_release_comment_stmt();

  private:
  const ::pg_query::CommentStmt& _internal_comment_stmt() const;
  ::pg_query::CommentStmt* _internal_mutable_comment_stmt();

  public:
  // .pg_query.SecLabelStmt sec_label_stmt = 178 [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;
  PROTOBUF_NODISCARD ::pg_query::SecLabelStmt* release_sec_label_stmt();
  ::pg_query::SecLabelStmt* mutable_sec_label_stmt();
  void set_allocated_sec_label_stmt(::pg_query::SecLabelStmt* value);
  void unsafe_arena_set_allocated_sec_label_stmt(::pg_query::SecLabelStmt* value);
  ::pg_query::SecLabelStmt* unsafe_arena_release_sec_label_stmt();

  private:
  const ::pg_query::SecLabelStmt& _internal_sec_label_stmt() const;
  ::pg_query::SecLabelStmt* _internal_mutable_sec_label_stmt();

  public:
  // .pg_query.DeclareCursorStmt declare_cursor_stmt = 179 [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;
  PROTOBUF_NODISCARD ::pg_query::DeclareCursorStmt* release_declare_cursor_stmt();
  ::pg_query::DeclareCursorStmt* mutable_declare_cursor_stmt();
  void set_allocated_declare_cursor_stmt(::pg_query::DeclareCursorStmt* value);
  void unsafe_arena_set_allocated_declare_cursor_stmt(::pg_query::DeclareCursorStmt* value);
  ::pg_query::DeclareCursorStmt* unsafe_arena_release_declare_cursor_stmt();

  private:
  const ::pg_query::DeclareCursorStmt& _internal_declare_cursor_stmt() const;
  ::pg_query::DeclareCursorStmt* _internal_mutable_declare_cursor_stmt();

  public:
  // .pg_query.ClosePortalStmt close_portal_stmt = 180 [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;
  PROTOBUF_NODISCARD ::pg_query::ClosePortalStmt* release_close_portal_stmt();
  ::pg_query::ClosePortalStmt* mutable_close_portal_stmt();
  void set_allocated_close_portal_stmt(::pg_query::ClosePortalStmt* value);
  void unsafe_arena_set_allocated_close_portal_stmt(::pg_query::ClosePortalStmt* value);
  ::pg_query::ClosePortalStmt* unsafe_arena_release_close_portal_stmt();

  private:
  const ::pg_query::ClosePortalStmt& _internal_close_portal_stmt() const;
  ::pg_query::ClosePortalStmt* _internal_mutable_close_portal_stmt();

  public:
  // .pg_query.FetchStmt fetch_stmt = 181 [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;
  PROTOBUF_NODISCARD ::pg_query::FetchStmt* release_fetch_stmt();
  ::pg_query::FetchStmt* mutable_fetch_stmt();
  void set_allocated_fetch_stmt(::pg_query::FetchStmt* value);
  void unsafe_arena_set_allocated_fetch_stmt(::pg_query::FetchStmt* value);
  ::pg_query::FetchStmt* unsafe_arena_release_fetch_stmt();

  private:
  const ::pg_query::FetchStmt& _internal_fetch_stmt() const;
  ::pg_query::FetchStmt* _internal_mutable_fetch_stmt();

  public:
  // .pg_query.IndexStmt index_stmt = 182 [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;
  PROTOBUF_NODISCARD ::pg_query::IndexStmt* release_index_stmt();
  ::pg_query::IndexStmt* mutable_index_stmt();
  void set_allocated_index_stmt(::pg_query::IndexStmt* value);
  void unsafe_arena_set_allocated_index_stmt(::pg_query::IndexStmt* value);
  ::pg_query::IndexStmt* unsafe_arena_release_index_stmt();

  private:
  const ::pg_query::IndexStmt& _internal_index_stmt() const;
  ::pg_query::IndexStmt* _internal_mutable_index_stmt();

  public:
  // .pg_query.CreateStatsStmt create_stats_stmt = 183 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateStatsStmt* release_create_stats_stmt();
  ::pg_query::CreateStatsStmt* mutable_create_stats_stmt();
  void set_allocated_create_stats_stmt(::pg_query::CreateStatsStmt* value);
  void unsafe_arena_set_allocated_create_stats_stmt(::pg_query::CreateStatsStmt* value);
  ::pg_query::CreateStatsStmt* unsafe_arena_release_create_stats_stmt();

  private:
  const ::pg_query::CreateStatsStmt& _internal_create_stats_stmt() const;
  ::pg_query::CreateStatsStmt* _internal_mutable_create_stats_stmt();

  public:
  // .pg_query.StatsElem stats_elem = 184 [json_name = "StatsElem"];
  bool has_stats_elem() const;
  private:
  bool _internal_has_stats_elem() const;

  public:
  void clear_stats_elem() ;
  const ::pg_query::StatsElem& stats_elem() const;
  PROTOBUF_NODISCARD ::pg_query::StatsElem* release_stats_elem();
  ::pg_query::StatsElem* mutable_stats_elem();
  void set_allocated_stats_elem(::pg_query::StatsElem* value);
  void unsafe_arena_set_allocated_stats_elem(::pg_query::StatsElem* value);
  ::pg_query::StatsElem* unsafe_arena_release_stats_elem();

  private:
  const ::pg_query::StatsElem& _internal_stats_elem() const;
  ::pg_query::StatsElem* _internal_mutable_stats_elem();

  public:
  // .pg_query.AlterStatsStmt alter_stats_stmt = 185 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterStatsStmt* release_alter_stats_stmt();
  ::pg_query::AlterStatsStmt* mutable_alter_stats_stmt();
  void set_allocated_alter_stats_stmt(::pg_query::AlterStatsStmt* value);
  void unsafe_arena_set_allocated_alter_stats_stmt(::pg_query::AlterStatsStmt* value);
  ::pg_query::AlterStatsStmt* unsafe_arena_release_alter_stats_stmt();

  private:
  const ::pg_query::AlterStatsStmt& _internal_alter_stats_stmt() const;
  ::pg_query::AlterStatsStmt* _internal_mutable_alter_stats_stmt();

  public:
  // .pg_query.CreateFunctionStmt create_function_stmt = 186 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateFunctionStmt* release_create_function_stmt();
  ::pg_query::CreateFunctionStmt* mutable_create_function_stmt();
  void set_allocated_create_function_stmt(::pg_query::CreateFunctionStmt* value);
  void unsafe_arena_set_allocated_create_function_stmt(::pg_query::CreateFunctionStmt* value);
  ::pg_query::CreateFunctionStmt* unsafe_arena_release_create_function_stmt();

  private:
  const ::pg_query::CreateFunctionStmt& _internal_create_function_stmt() const;
  ::pg_query::CreateFunctionStmt* _internal_mutable_create_function_stmt();

  public:
  // .pg_query.FunctionParameter function_parameter = 187 [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;
  PROTOBUF_NODISCARD ::pg_query::FunctionParameter* release_function_parameter();
  ::pg_query::FunctionParameter* mutable_function_parameter();
  void set_allocated_function_parameter(::pg_query::FunctionParameter* value);
  void unsafe_arena_set_allocated_function_parameter(::pg_query::FunctionParameter* value);
  ::pg_query::FunctionParameter* unsafe_arena_release_function_parameter();

  private:
  const ::pg_query::FunctionParameter& _internal_function_parameter() const;
  ::pg_query::FunctionParameter* _internal_mutable_function_parameter();

  public:
  // .pg_query.AlterFunctionStmt alter_function_stmt = 188 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterFunctionStmt* release_alter_function_stmt();
  ::pg_query::AlterFunctionStmt* mutable_alter_function_stmt();
  void set_allocated_alter_function_stmt(::pg_query::AlterFunctionStmt* value);
  void unsafe_arena_set_allocated_alter_function_stmt(::pg_query::AlterFunctionStmt* value);
  ::pg_query::AlterFunctionStmt* unsafe_arena_release_alter_function_stmt();

  private:
  const ::pg_query::AlterFunctionStmt& _internal_alter_function_stmt() const;
  ::pg_query::AlterFunctionStmt* _internal_mutable_alter_function_stmt();

  public:
  // .pg_query.DoStmt do_stmt = 189 [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;
  PROTOBUF_NODISCARD ::pg_query::DoStmt* release_do_stmt();
  ::pg_query::DoStmt* mutable_do_stmt();
  void set_allocated_do_stmt(::pg_query::DoStmt* value);
  void unsafe_arena_set_allocated_do_stmt(::pg_query::DoStmt* value);
  ::pg_query::DoStmt* unsafe_arena_release_do_stmt();

  private:
  const ::pg_query::DoStmt& _internal_do_stmt() const;
  ::pg_query::DoStmt* _internal_mutable_do_stmt();

  public:
  // .pg_query.InlineCodeBlock inline_code_block = 190 [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;
  PROTOBUF_NODISCARD ::pg_query::InlineCodeBlock* release_inline_code_block();
  ::pg_query::InlineCodeBlock* mutable_inline_code_block();
  void set_allocated_inline_code_block(::pg_query::InlineCodeBlock* value);
  void unsafe_arena_set_allocated_inline_code_block(::pg_query::InlineCodeBlock* value);
  ::pg_query::InlineCodeBlock* unsafe_arena_release_inline_code_block();

  private:
  const ::pg_query::InlineCodeBlock& _internal_inline_code_block() const;
  ::pg_query::InlineCodeBlock* _internal_mutable_inline_code_block();

  public:
  // .pg_query.CallStmt call_stmt = 191 [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;
  PROTOBUF_NODISCARD ::pg_query::CallStmt* release_call_stmt();
  ::pg_query::CallStmt* mutable_call_stmt();
  void set_allocated_call_stmt(::pg_query::CallStmt* value);
  void unsafe_arena_set_allocated_call_stmt(::pg_query::CallStmt* value);
  ::pg_query::CallStmt* unsafe_arena_release_call_stmt();

  private:
  const ::pg_query::CallStmt& _internal_call_stmt() const;
  ::pg_query::CallStmt* _internal_mutable_call_stmt();

  public:
  // .pg_query.CallContext call_context = 192 [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;
  PROTOBUF_NODISCARD ::pg_query::CallContext* release_call_context();
  ::pg_query::CallContext* mutable_call_context();
  void set_allocated_call_context(::pg_query::CallContext* value);
  void unsafe_arena_set_allocated_call_context(::pg_query::CallContext* value);
  ::pg_query::CallContext* unsafe_arena_release_call_context();

  private:
  const ::pg_query::CallContext& _internal_call_context() const;
  ::pg_query::CallContext* _internal_mutable_call_context();

  public:
  // .pg_query.RenameStmt rename_stmt = 193 [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;
  PROTOBUF_NODISCARD ::pg_query::RenameStmt* release_rename_stmt();
  ::pg_query::RenameStmt* mutable_rename_stmt();
  void set_allocated_rename_stmt(::pg_query::RenameStmt* value);
  void unsafe_arena_set_allocated_rename_stmt(::pg_query::RenameStmt* value);
  ::pg_query::RenameStmt* unsafe_arena_release_rename_stmt();

  private:
  const ::pg_query::RenameStmt& _internal_rename_stmt() const;
  ::pg_query::RenameStmt* _internal_mutable_rename_stmt();

  public:
  // .pg_query.AlterObjectDependsStmt alter_object_depends_stmt = 194 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_alter_object_depends_stmt(::pg_query::AlterObjectDependsStmt* value);
  ::pg_query::AlterObjectDependsStmt* unsafe_arena_release_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:
  // .pg_query.AlterObjectSchemaStmt alter_object_schema_stmt = 195 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_alter_object_schema_stmt(::pg_query::AlterObjectSchemaStmt* value);
  ::pg_query::AlterObjectSchemaStmt* unsafe_arena_release_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:
  // .pg_query.AlterOwnerStmt alter_owner_stmt = 196 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterOwnerStmt* release_alter_owner_stmt();
  ::pg_query::AlterOwnerStmt* mutable_alter_owner_stmt();
  void set_allocated_alter_owner_stmt(::pg_query::AlterOwnerStmt* value);
  void unsafe_arena_set_allocated_alter_owner_stmt(::pg_query::AlterOwnerStmt* value);
  ::pg_query::AlterOwnerStmt* unsafe_arena_release_alter_owner_stmt();

  private:
  const ::pg_query::AlterOwnerStmt& _internal_alter_owner_stmt() const;
  ::pg_query::AlterOwnerStmt* _internal_mutable_alter_owner_stmt();

  public:
  // .pg_query.AlterOperatorStmt alter_operator_stmt = 197 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterOperatorStmt* release_alter_operator_stmt();
  ::pg_query::AlterOperatorStmt* mutable_alter_operator_stmt();
  void set_allocated_alter_operator_stmt(::pg_query::AlterOperatorStmt* value);
  void unsafe_arena_set_allocated_alter_operator_stmt(::pg_query::AlterOperatorStmt* value);
  ::pg_query::AlterOperatorStmt* unsafe_arena_release_alter_operator_stmt();

  private:
  const ::pg_query::AlterOperatorStmt& _internal_alter_operator_stmt() const;
  ::pg_query::AlterOperatorStmt* _internal_mutable_alter_operator_stmt();

  public:
  // .pg_query.AlterTypeStmt alter_type_stmt = 198 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterTypeStmt* release_alter_type_stmt();
  ::pg_query::AlterTypeStmt* mutable_alter_type_stmt();
  void set_allocated_alter_type_stmt(::pg_query::AlterTypeStmt* value);
  void unsafe_arena_set_allocated_alter_type_stmt(::pg_query::AlterTypeStmt* value);
  ::pg_query::AlterTypeStmt* unsafe_arena_release_alter_type_stmt();

  private:
  const ::pg_query::AlterTypeStmt& _internal_alter_type_stmt() const;
  ::pg_query::AlterTypeStmt* _internal_mutable_alter_type_stmt();

  public:
  // .pg_query.RuleStmt rule_stmt = 199 [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;
  PROTOBUF_NODISCARD ::pg_query::RuleStmt* release_rule_stmt();
  ::pg_query::RuleStmt* mutable_rule_stmt();
  void set_allocated_rule_stmt(::pg_query::RuleStmt* value);
  void unsafe_arena_set_allocated_rule_stmt(::pg_query::RuleStmt* value);
  ::pg_query::RuleStmt* unsafe_arena_release_rule_stmt();

  private:
  const ::pg_query::RuleStmt& _internal_rule_stmt() const;
  ::pg_query::RuleStmt* _internal_mutable_rule_stmt();

  public:
  // .pg_query.NotifyStmt notify_stmt = 200 [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;
  PROTOBUF_NODISCARD ::pg_query::NotifyStmt* release_notify_stmt();
  ::pg_query::NotifyStmt* mutable_notify_stmt();
  void set_allocated_notify_stmt(::pg_query::NotifyStmt* value);
  void unsafe_arena_set_allocated_notify_stmt(::pg_query::NotifyStmt* value);
  ::pg_query::NotifyStmt* unsafe_arena_release_notify_stmt();

  private:
  const ::pg_query::NotifyStmt& _internal_notify_stmt() const;
  ::pg_query::NotifyStmt* _internal_mutable_notify_stmt();

  public:
  // .pg_query.ListenStmt listen_stmt = 201 [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;
  PROTOBUF_NODISCARD ::pg_query::ListenStmt* release_listen_stmt();
  ::pg_query::ListenStmt* mutable_listen_stmt();
  void set_allocated_listen_stmt(::pg_query::ListenStmt* value);
  void unsafe_arena_set_allocated_listen_stmt(::pg_query::ListenStmt* value);
  ::pg_query::ListenStmt* unsafe_arena_release_listen_stmt();

  private:
  const ::pg_query::ListenStmt& _internal_listen_stmt() const;
  ::pg_query::ListenStmt* _internal_mutable_listen_stmt();

  public:
  // .pg_query.UnlistenStmt unlisten_stmt = 202 [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;
  PROTOBUF_NODISCARD ::pg_query::UnlistenStmt* release_unlisten_stmt();
  ::pg_query::UnlistenStmt* mutable_unlisten_stmt();
  void set_allocated_unlisten_stmt(::pg_query::UnlistenStmt* value);
  void unsafe_arena_set_allocated_unlisten_stmt(::pg_query::UnlistenStmt* value);
  ::pg_query::UnlistenStmt* unsafe_arena_release_unlisten_stmt();

  private:
  const ::pg_query::UnlistenStmt& _internal_unlisten_stmt() const;
  ::pg_query::UnlistenStmt* _internal_mutable_unlisten_stmt();

  public:
  // .pg_query.TransactionStmt transaction_stmt = 203 [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;
  PROTOBUF_NODISCARD ::pg_query::TransactionStmt* release_transaction_stmt();
  ::pg_query::TransactionStmt* mutable_transaction_stmt();
  void set_allocated_transaction_stmt(::pg_query::TransactionStmt* value);
  void unsafe_arena_set_allocated_transaction_stmt(::pg_query::TransactionStmt* value);
  ::pg_query::TransactionStmt* unsafe_arena_release_transaction_stmt();

  private:
  const ::pg_query::TransactionStmt& _internal_transaction_stmt() const;
  ::pg_query::TransactionStmt* _internal_mutable_transaction_stmt();

  public:
  // .pg_query.CompositeTypeStmt composite_type_stmt = 204 [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;
  PROTOBUF_NODISCARD ::pg_query::CompositeTypeStmt* release_composite_type_stmt();
  ::pg_query::CompositeTypeStmt* mutable_composite_type_stmt();
  void set_allocated_composite_type_stmt(::pg_query::CompositeTypeStmt* value);
  void unsafe_arena_set_allocated_composite_type_stmt(::pg_query::CompositeTypeStmt* value);
  ::pg_query::CompositeTypeStmt* unsafe_arena_release_composite_type_stmt();

  private:
  const ::pg_query::CompositeTypeStmt& _internal_composite_type_stmt() const;
  ::pg_query::CompositeTypeStmt* _internal_mutable_composite_type_stmt();

  public:
  // .pg_query.CreateEnumStmt create_enum_stmt = 205 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateEnumStmt* release_create_enum_stmt();
  ::pg_query::CreateEnumStmt* mutable_create_enum_stmt();
  void set_allocated_create_enum_stmt(::pg_query::CreateEnumStmt* value);
  void unsafe_arena_set_allocated_create_enum_stmt(::pg_query::CreateEnumStmt* value);
  ::pg_query::CreateEnumStmt* unsafe_arena_release_create_enum_stmt();

  private:
  const ::pg_query::CreateEnumStmt& _internal_create_enum_stmt() const;
  ::pg_query::CreateEnumStmt* _internal_mutable_create_enum_stmt();

  public:
  // .pg_query.CreateRangeStmt create_range_stmt = 206 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateRangeStmt* release_create_range_stmt();
  ::pg_query::CreateRangeStmt* mutable_create_range_stmt();
  void set_allocated_create_range_stmt(::pg_query::CreateRangeStmt* value);
  void unsafe_arena_set_allocated_create_range_stmt(::pg_query::CreateRangeStmt* value);
  ::pg_query::CreateRangeStmt* unsafe_arena_release_create_range_stmt();

  private:
  const ::pg_query::CreateRangeStmt& _internal_create_range_stmt() const;
  ::pg_query::CreateRangeStmt* _internal_mutable_create_range_stmt();

  public:
  // .pg_query.AlterEnumStmt alter_enum_stmt = 207 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterEnumStmt* release_alter_enum_stmt();
  ::pg_query::AlterEnumStmt* mutable_alter_enum_stmt();
  void set_allocated_alter_enum_stmt(::pg_query::AlterEnumStmt* value);
  void unsafe_arena_set_allocated_alter_enum_stmt(::pg_query::AlterEnumStmt* value);
  ::pg_query::AlterEnumStmt* unsafe_arena_release_alter_enum_stmt();

  private:
  const ::pg_query::AlterEnumStmt& _internal_alter_enum_stmt() const;
  ::pg_query::AlterEnumStmt* _internal_mutable_alter_enum_stmt();

  public:
  // .pg_query.ViewStmt view_stmt = 208 [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;
  PROTOBUF_NODISCARD ::pg_query::ViewStmt* release_view_stmt();
  ::pg_query::ViewStmt* mutable_view_stmt();
  void set_allocated_view_stmt(::pg_query::ViewStmt* value);
  void unsafe_arena_set_allocated_view_stmt(::pg_query::ViewStmt* value);
  ::pg_query::ViewStmt* unsafe_arena_release_view_stmt();

  private:
  const ::pg_query::ViewStmt& _internal_view_stmt() const;
  ::pg_query::ViewStmt* _internal_mutable_view_stmt();

  public:
  // .pg_query.LoadStmt load_stmt = 209 [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;
  PROTOBUF_NODISCARD ::pg_query::LoadStmt* release_load_stmt();
  ::pg_query::LoadStmt* mutable_load_stmt();
  void set_allocated_load_stmt(::pg_query::LoadStmt* value);
  void unsafe_arena_set_allocated_load_stmt(::pg_query::LoadStmt* value);
  ::pg_query::LoadStmt* unsafe_arena_release_load_stmt();

  private:
  const ::pg_query::LoadStmt& _internal_load_stmt() const;
  ::pg_query::LoadStmt* _internal_mutable_load_stmt();

  public:
  // .pg_query.CreatedbStmt createdb_stmt = 210 [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;
  PROTOBUF_NODISCARD ::pg_query::CreatedbStmt* release_createdb_stmt();
  ::pg_query::CreatedbStmt* mutable_createdb_stmt();
  void set_allocated_createdb_stmt(::pg_query::CreatedbStmt* value);
  void unsafe_arena_set_allocated_createdb_stmt(::pg_query::CreatedbStmt* value);
  ::pg_query::CreatedbStmt* unsafe_arena_release_createdb_stmt();

  private:
  const ::pg_query::CreatedbStmt& _internal_createdb_stmt() const;
  ::pg_query::CreatedbStmt* _internal_mutable_createdb_stmt();

  public:
  // .pg_query.AlterDatabaseStmt alter_database_stmt = 211 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterDatabaseStmt* release_alter_database_stmt();
  ::pg_query::AlterDatabaseStmt* mutable_alter_database_stmt();
  void set_allocated_alter_database_stmt(::pg_query::AlterDatabaseStmt* value);
  void unsafe_arena_set_allocated_alter_database_stmt(::pg_query::AlterDatabaseStmt* value);
  ::pg_query::AlterDatabaseStmt* unsafe_arena_release_alter_database_stmt();

  private:
  const ::pg_query::AlterDatabaseStmt& _internal_alter_database_stmt() const;
  ::pg_query::AlterDatabaseStmt* _internal_mutable_alter_database_stmt();

  public:
  // .pg_query.AlterDatabaseRefreshCollStmt alter_database_refresh_coll_stmt = 212 [json_name = "AlterDatabaseRefreshCollStmt"];
  bool has_alter_database_refresh_coll_stmt() const;
  private:
  bool _internal_has_alter_database_refresh_coll_stmt() const;

  public:
  void clear_alter_database_refresh_coll_stmt() ;
  const ::pg_query::AlterDatabaseRefreshCollStmt& alter_database_refresh_coll_stmt() const;
  PROTOBUF_NODISCARD ::pg_query::AlterDatabaseRefreshCollStmt* release_alter_database_refresh_coll_stmt();
  ::pg_query::AlterDatabaseRefreshCollStmt* mutable_alter_database_refresh_coll_stmt();
  void set_allocated_alter_database_refresh_coll_stmt(::pg_query::AlterDatabaseRefreshCollStmt* value);
  void unsafe_arena_set_allocated_alter_database_refresh_coll_stmt(::pg_query::AlterDatabaseRefreshCollStmt* value);
  ::pg_query::AlterDatabaseRefreshCollStmt* unsafe_arena_release_alter_database_refresh_coll_stmt();

  private:
  const ::pg_query::AlterDatabaseRefreshCollStmt& _internal_alter_database_refresh_coll_stmt() const;
  ::pg_query::AlterDatabaseRefreshCollStmt* _internal_mutable_alter_database_refresh_coll_stmt();

  public:
  // .pg_query.AlterDatabaseSetStmt alter_database_set_stmt = 213 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_alter_database_set_stmt(::pg_query::AlterDatabaseSetStmt* value);
  ::pg_query::AlterDatabaseSetStmt* unsafe_arena_release_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:
  // .pg_query.DropdbStmt dropdb_stmt = 214 [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;
  PROTOBUF_NODISCARD ::pg_query::DropdbStmt* release_dropdb_stmt();
  ::pg_query::DropdbStmt* mutable_dropdb_stmt();
  void set_allocated_dropdb_stmt(::pg_query::DropdbStmt* value);
  void unsafe_arena_set_allocated_dropdb_stmt(::pg_query::DropdbStmt* value);
  ::pg_query::DropdbStmt* unsafe_arena_release_dropdb_stmt();

  private:
  const ::pg_query::DropdbStmt& _internal_dropdb_stmt() const;
  ::pg_query::DropdbStmt* _internal_mutable_dropdb_stmt();

  public:
  // .pg_query.AlterSystemStmt alter_system_stmt = 215 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterSystemStmt* release_alter_system_stmt();
  ::pg_query::AlterSystemStmt* mutable_alter_system_stmt();
  void set_allocated_alter_system_stmt(::pg_query::AlterSystemStmt* value);
  void unsafe_arena_set_allocated_alter_system_stmt(::pg_query::AlterSystemStmt* value);
  ::pg_query::AlterSystemStmt* unsafe_arena_release_alter_system_stmt();

  private:
  const ::pg_query::AlterSystemStmt& _internal_alter_system_stmt() const;
  ::pg_query::AlterSystemStmt* _internal_mutable_alter_system_stmt();

  public:
  // .pg_query.ClusterStmt cluster_stmt = 216 [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;
  PROTOBUF_NODISCARD ::pg_query::ClusterStmt* release_cluster_stmt();
  ::pg_query::ClusterStmt* mutable_cluster_stmt();
  void set_allocated_cluster_stmt(::pg_query::ClusterStmt* value);
  void unsafe_arena_set_allocated_cluster_stmt(::pg_query::ClusterStmt* value);
  ::pg_query::ClusterStmt* unsafe_arena_release_cluster_stmt();

  private:
  const ::pg_query::ClusterStmt& _internal_cluster_stmt() const;
  ::pg_query::ClusterStmt* _internal_mutable_cluster_stmt();

  public:
  // .pg_query.VacuumStmt vacuum_stmt = 217 [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;
  PROTOBUF_NODISCARD ::pg_query::VacuumStmt* release_vacuum_stmt();
  ::pg_query::VacuumStmt* mutable_vacuum_stmt();
  void set_allocated_vacuum_stmt(::pg_query::VacuumStmt* value);
  void unsafe_arena_set_allocated_vacuum_stmt(::pg_query::VacuumStmt* value);
  ::pg_query::VacuumStmt* unsafe_arena_release_vacuum_stmt();

  private:
  const ::pg_query::VacuumStmt& _internal_vacuum_stmt() const;
  ::pg_query::VacuumStmt* _internal_mutable_vacuum_stmt();

  public:
  // .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;
  PROTOBUF_NODISCARD ::pg_query::VacuumRelation* release_vacuum_relation();
  ::pg_query::VacuumRelation* mutable_vacuum_relation();
  void set_allocated_vacuum_relation(::pg_query::VacuumRelation* value);
  void unsafe_arena_set_allocated_vacuum_relation(::pg_query::VacuumRelation* value);
  ::pg_query::VacuumRelation* unsafe_arena_release_vacuum_relation();

  private:
  const ::pg_query::VacuumRelation& _internal_vacuum_relation() const;
  ::pg_query::VacuumRelation* _internal_mutable_vacuum_relation();

  public:
  // .pg_query.ExplainStmt explain_stmt = 219 [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;
  PROTOBUF_NODISCARD ::pg_query::ExplainStmt* release_explain_stmt();
  ::pg_query::ExplainStmt* mutable_explain_stmt();
  void set_allocated_explain_stmt(::pg_query::ExplainStmt* value);
  void unsafe_arena_set_allocated_explain_stmt(::pg_query::ExplainStmt* value);
  ::pg_query::ExplainStmt* unsafe_arena_release_explain_stmt();

  private:
  const ::pg_query::ExplainStmt& _internal_explain_stmt() const;
  ::pg_query::ExplainStmt* _internal_mutable_explain_stmt();

  public:
  // .pg_query.CreateTableAsStmt create_table_as_stmt = 220 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_create_table_as_stmt(::pg_query::CreateTableAsStmt* value);
  ::pg_query::CreateTableAsStmt* unsafe_arena_release_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:
  // .pg_query.RefreshMatViewStmt refresh_mat_view_stmt = 221 [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;
  PROTOBUF_NODISCARD ::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* value);
  void unsafe_arena_set_allocated_refresh_mat_view_stmt(::pg_query::RefreshMatViewStmt* value);
  ::pg_query::RefreshMatViewStmt* unsafe_arena_release_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:
  // .pg_query.CheckPointStmt check_point_stmt = 222 [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;
  PROTOBUF_NODISCARD ::pg_query::CheckPointStmt* release_check_point_stmt();
  ::pg_query::CheckPointStmt* mutable_check_point_stmt();
  void set_allocated_check_point_stmt(::pg_query::CheckPointStmt* value);
  void unsafe_arena_set_allocated_check_point_stmt(::pg_query::CheckPointStmt* value);
  ::pg_query::CheckPointStmt* unsafe_arena_release_check_point_stmt();

  private:
  const ::pg_query::CheckPointStmt& _internal_check_point_stmt() const;
  ::pg_query::CheckPointStmt* _internal_mutable_check_point_stmt();

  public:
  // .pg_query.DiscardStmt discard_stmt = 223 [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;
  PROTOBUF_NODISCARD ::pg_query::DiscardStmt* release_discard_stmt();
  ::pg_query::DiscardStmt* mutable_discard_stmt();
  void set_allocated_discard_stmt(::pg_query::DiscardStmt* value);
  void unsafe_arena_set_allocated_discard_stmt(::pg_query::DiscardStmt* value);
  ::pg_query::DiscardStmt* unsafe_arena_release_discard_stmt();

  private:
  const ::pg_query::DiscardStmt& _internal_discard_stmt() const;
  ::pg_query::DiscardStmt* _internal_mutable_discard_stmt();

  public:
  // .pg_query.LockStmt lock_stmt = 224 [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;
  PROTOBUF_NODISCARD ::pg_query::LockStmt* release_lock_stmt();
  ::pg_query::LockStmt* mutable_lock_stmt();
  void set_allocated_lock_stmt(::pg_query::LockStmt* value);
  void unsafe_arena_set_allocated_lock_stmt(::pg_query::LockStmt* value);
  ::pg_query::LockStmt* unsafe_arena_release_lock_stmt();

  private:
  const ::pg_query::LockStmt& _internal_lock_stmt() const;
  ::pg_query::LockStmt* _internal_mutable_lock_stmt();

  public:
  // .pg_query.ConstraintsSetStmt constraints_set_stmt = 225 [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;
  PROTOBUF_NODISCARD ::pg_query::ConstraintsSetStmt* release_constraints_set_stmt();
  ::pg_query::ConstraintsSetStmt* mutable_constraints_set_stmt();
  void set_allocated_constraints_set_stmt(::pg_query::ConstraintsSetStmt* value);
  void unsafe_arena_set_allocated_constraints_set_stmt(::pg_query::ConstraintsSetStmt* value);
  ::pg_query::ConstraintsSetStmt* unsafe_arena_release_constraints_set_stmt();

  private:
  const ::pg_query::ConstraintsSetStmt& _internal_constraints_set_stmt() const;
  ::pg_query::ConstraintsSetStmt* _internal_mutable_constraints_set_stmt();

  public:
  // .pg_query.ReindexStmt reindex_stmt = 226 [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;
  PROTOBUF_NODISCARD ::pg_query::ReindexStmt* release_reindex_stmt();
  ::pg_query::ReindexStmt* mutable_reindex_stmt();
  void set_allocated_reindex_stmt(::pg_query::ReindexStmt* value);
  void unsafe_arena_set_allocated_reindex_stmt(::pg_query::ReindexStmt* value);
  ::pg_query::ReindexStmt* unsafe_arena_release_reindex_stmt();

  private:
  const ::pg_query::ReindexStmt& _internal_reindex_stmt() const;
  ::pg_query::ReindexStmt* _internal_mutable_reindex_stmt();

  public:
  // .pg_query.CreateConversionStmt create_conversion_stmt = 227 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateConversionStmt* release_create_conversion_stmt();
  ::pg_query::CreateConversionStmt* mutable_create_conversion_stmt();
  void set_allocated_create_conversion_stmt(::pg_query::CreateConversionStmt* value);
  void unsafe_arena_set_allocated_create_conversion_stmt(::pg_query::CreateConversionStmt* value);
  ::pg_query::CreateConversionStmt* unsafe_arena_release_create_conversion_stmt();

  private:
  const ::pg_query::CreateConversionStmt& _internal_create_conversion_stmt() const;
  ::pg_query::CreateConversionStmt* _internal_mutable_create_conversion_stmt();

  public:
  // .pg_query.CreateCastStmt create_cast_stmt = 228 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateCastStmt* release_create_cast_stmt();
  ::pg_query::CreateCastStmt* mutable_create_cast_stmt();
  void set_allocated_create_cast_stmt(::pg_query::CreateCastStmt* value);
  void unsafe_arena_set_allocated_create_cast_stmt(::pg_query::CreateCastStmt* value);
  ::pg_query::CreateCastStmt* unsafe_arena_release_create_cast_stmt();

  private:
  const ::pg_query::CreateCastStmt& _internal_create_cast_stmt() const;
  ::pg_query::CreateCastStmt* _internal_mutable_create_cast_stmt();

  public:
  // .pg_query.CreateTransformStmt create_transform_stmt = 229 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateTransformStmt* release_create_transform_stmt();
  ::pg_query::CreateTransformStmt* mutable_create_transform_stmt();
  void set_allocated_create_transform_stmt(::pg_query::CreateTransformStmt* value);
  void unsafe_arena_set_allocated_create_transform_stmt(::pg_query::CreateTransformStmt* value);
  ::pg_query::CreateTransformStmt* unsafe_arena_release_create_transform_stmt();

  private:
  const ::pg_query::CreateTransformStmt& _internal_create_transform_stmt() const;
  ::pg_query::CreateTransformStmt* _internal_mutable_create_transform_stmt();

  public:
  // .pg_query.PrepareStmt prepare_stmt = 230 [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;
  PROTOBUF_NODISCARD ::pg_query::PrepareStmt* release_prepare_stmt();
  ::pg_query::PrepareStmt* mutable_prepare_stmt();
  void set_allocated_prepare_stmt(::pg_query::PrepareStmt* value);
  void unsafe_arena_set_allocated_prepare_stmt(::pg_query::PrepareStmt* value);
  ::pg_query::PrepareStmt* unsafe_arena_release_prepare_stmt();

  private:
  const ::pg_query::PrepareStmt& _internal_prepare_stmt() const;
  ::pg_query::PrepareStmt* _internal_mutable_prepare_stmt();

  public:
  // .pg_query.ExecuteStmt execute_stmt = 231 [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;
  PROTOBUF_NODISCARD ::pg_query::ExecuteStmt* release_execute_stmt();
  ::pg_query::ExecuteStmt* mutable_execute_stmt();
  void set_allocated_execute_stmt(::pg_query::ExecuteStmt* value);
  void unsafe_arena_set_allocated_execute_stmt(::pg_query::ExecuteStmt* value);
  ::pg_query::ExecuteStmt* unsafe_arena_release_execute_stmt();

  private:
  const ::pg_query::ExecuteStmt& _internal_execute_stmt() const;
  ::pg_query::ExecuteStmt* _internal_mutable_execute_stmt();

  public:
  // .pg_query.DeallocateStmt deallocate_stmt = 232 [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;
  PROTOBUF_NODISCARD ::pg_query::DeallocateStmt* release_deallocate_stmt();
  ::pg_query::DeallocateStmt* mutable_deallocate_stmt();
  void set_allocated_deallocate_stmt(::pg_query::DeallocateStmt* value);
  void unsafe_arena_set_allocated_deallocate_stmt(::pg_query::DeallocateStmt* value);
  ::pg_query::DeallocateStmt* unsafe_arena_release_deallocate_stmt();

  private:
  const ::pg_query::DeallocateStmt& _internal_deallocate_stmt() const;
  ::pg_query::DeallocateStmt* _internal_mutable_deallocate_stmt();

  public:
  // .pg_query.DropOwnedStmt drop_owned_stmt = 233 [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;
  PROTOBUF_NODISCARD ::pg_query::DropOwnedStmt* release_drop_owned_stmt();
  ::pg_query::DropOwnedStmt* mutable_drop_owned_stmt();
  void set_allocated_drop_owned_stmt(::pg_query::DropOwnedStmt* value);
  void unsafe_arena_set_allocated_drop_owned_stmt(::pg_query::DropOwnedStmt* value);
  ::pg_query::DropOwnedStmt* unsafe_arena_release_drop_owned_stmt();

  private:
  const ::pg_query::DropOwnedStmt& _internal_drop_owned_stmt() const;
  ::pg_query::DropOwnedStmt* _internal_mutable_drop_owned_stmt();

  public:
  // .pg_query.ReassignOwnedStmt reassign_owned_stmt = 234 [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;
  PROTOBUF_NODISCARD ::pg_query::ReassignOwnedStmt* release_reassign_owned_stmt();
  ::pg_query::ReassignOwnedStmt* mutable_reassign_owned_stmt();
  void set_allocated_reassign_owned_stmt(::pg_query::ReassignOwnedStmt* value);
  void unsafe_arena_set_allocated_reassign_owned_stmt(::pg_query::ReassignOwnedStmt* value);
  ::pg_query::ReassignOwnedStmt* unsafe_arena_release_reassign_owned_stmt();

  private:
  const ::pg_query::ReassignOwnedStmt& _internal_reassign_owned_stmt() const;
  ::pg_query::ReassignOwnedStmt* _internal_mutable_reassign_owned_stmt();

  public:
  // .pg_query.AlterTSDictionaryStmt alter_tsdictionary_stmt = 235 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterTSDictionaryStmt* release_alter_tsdictionary_stmt();
  ::pg_query::AlterTSDictionaryStmt* mutable_alter_tsdictionary_stmt();
  void set_allocated_alter_tsdictionary_stmt(::pg_query::AlterTSDictionaryStmt* value);
  void unsafe_arena_set_allocated_alter_tsdictionary_stmt(::pg_query::AlterTSDictionaryStmt* value);
  ::pg_query::AlterTSDictionaryStmt* unsafe_arena_release_alter_tsdictionary_stmt();

  private:
  const ::pg_query::AlterTSDictionaryStmt& _internal_alter_tsdictionary_stmt() const;
  ::pg_query::AlterTSDictionaryStmt* _internal_mutable_alter_tsdictionary_stmt();

  public:
  // .pg_query.AlterTSConfigurationStmt alter_tsconfiguration_stmt = 236 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterTSConfigurationStmt* release_alter_tsconfiguration_stmt();
  ::pg_query::AlterTSConfigurationStmt* mutable_alter_tsconfiguration_stmt();
  void set_allocated_alter_tsconfiguration_stmt(::pg_query::AlterTSConfigurationStmt* value);
  void unsafe_arena_set_allocated_alter_tsconfiguration_stmt(::pg_query::AlterTSConfigurationStmt* value);
  ::pg_query::AlterTSConfigurationStmt* unsafe_arena_release_alter_tsconfiguration_stmt();

  private:
  const ::pg_query::AlterTSConfigurationStmt& _internal_alter_tsconfiguration_stmt() const;
  ::pg_query::AlterTSConfigurationStmt* _internal_mutable_alter_tsconfiguration_stmt();

  public:
  // .pg_query.PublicationTable publication_table = 237 [json_name = "PublicationTable"];
  bool has_publication_table() const;
  private:
  bool _internal_has_publication_table() const;

  public:
  void clear_publication_table() ;
  const ::pg_query::PublicationTable& publication_table() const;
  PROTOBUF_NODISCARD ::pg_query::PublicationTable* release_publication_table();
  ::pg_query::PublicationTable* mutable_publication_table();
  void set_allocated_publication_table(::pg_query::PublicationTable* value);
  void unsafe_arena_set_allocated_publication_table(::pg_query::PublicationTable* value);
  ::pg_query::PublicationTable* unsafe_arena_release_publication_table();

  private:
  const ::pg_query::PublicationTable& _internal_publication_table() const;
  ::pg_query::PublicationTable* _internal_mutable_publication_table();

  public:
  // .pg_query.PublicationObjSpec publication_obj_spec = 238 [json_name = "PublicationObjSpec"];
  bool has_publication_obj_spec() const;
  private:
  bool _internal_has_publication_obj_spec() const;

  public:
  void clear_publication_obj_spec() ;
  const ::pg_query::PublicationObjSpec& publication_obj_spec() const;
  PROTOBUF_NODISCARD ::pg_query::PublicationObjSpec* release_publication_obj_spec();
  ::pg_query::PublicationObjSpec* mutable_publication_obj_spec();
  void set_allocated_publication_obj_spec(::pg_query::PublicationObjSpec* value);
  void unsafe_arena_set_allocated_publication_obj_spec(::pg_query::PublicationObjSpec* value);
  ::pg_query::PublicationObjSpec* unsafe_arena_release_publication_obj_spec();

  private:
  const ::pg_query::PublicationObjSpec& _internal_publication_obj_spec() const;
  ::pg_query::PublicationObjSpec* _internal_mutable_publication_obj_spec();

  public:
  // .pg_query.CreatePublicationStmt create_publication_stmt = 239 [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;
  PROTOBUF_NODISCARD ::pg_query::CreatePublicationStmt* release_create_publication_stmt();
  ::pg_query::CreatePublicationStmt* mutable_create_publication_stmt();
  void set_allocated_create_publication_stmt(::pg_query::CreatePublicationStmt* value);
  void unsafe_arena_set_allocated_create_publication_stmt(::pg_query::CreatePublicationStmt* value);
  ::pg_query::CreatePublicationStmt* unsafe_arena_release_create_publication_stmt();

  private:
  const ::pg_query::CreatePublicationStmt& _internal_create_publication_stmt() const;
  ::pg_query::CreatePublicationStmt* _internal_mutable_create_publication_stmt();

  public:
  // .pg_query.AlterPublicationStmt alter_publication_stmt = 240 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterPublicationStmt* release_alter_publication_stmt();
  ::pg_query::AlterPublicationStmt* mutable_alter_publication_stmt();
  void set_allocated_alter_publication_stmt(::pg_query::AlterPublicationStmt* value);
  void unsafe_arena_set_allocated_alter_publication_stmt(::pg_query::AlterPublicationStmt* value);
  ::pg_query::AlterPublicationStmt* unsafe_arena_release_alter_publication_stmt();

  private:
  const ::pg_query::AlterPublicationStmt& _internal_alter_publication_stmt() const;
  ::pg_query::AlterPublicationStmt* _internal_mutable_alter_publication_stmt();

  public:
  // .pg_query.CreateSubscriptionStmt create_subscription_stmt = 241 [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;
  PROTOBUF_NODISCARD ::pg_query::CreateSubscriptionStmt* release_create_subscription_stmt();
  ::pg_query::CreateSubscriptionStmt* mutable_create_subscription_stmt();
  void set_allocated_create_subscription_stmt(::pg_query::CreateSubscriptionStmt* value);
  void unsafe_arena_set_allocated_create_subscription_stmt(::pg_query::CreateSubscriptionStmt* value);
  ::pg_query::CreateSubscriptionStmt* unsafe_arena_release_create_subscription_stmt();

  private:
  const ::pg_query::CreateSubscriptionStmt& _internal_create_subscription_stmt() const;
  ::pg_query::CreateSubscriptionStmt* _internal_mutable_create_subscription_stmt();

  public:
  // .pg_query.AlterSubscriptionStmt alter_subscription_stmt = 242 [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;
  PROTOBUF_NODISCARD ::pg_query::AlterSubscriptionStmt* release_alter_subscription_stmt();
  ::pg_query::AlterSubscriptionStmt* mutable_alter_subscription_stmt();
  void set_allocated_alter_subscription_stmt(::pg_query::AlterSubscriptionStmt* value);
  void unsafe_arena_set_allocated_alter_subscription_stmt(::pg_query::AlterSubscriptionStmt* value);
  ::pg_query::AlterSubscriptionStmt* unsafe_arena_release_alter_subscription_stmt();

  private:
  const ::pg_query::AlterSubscriptionStmt& _internal_alter_subscription_stmt() const;
  ::pg_query::AlterSubscriptionStmt* _internal_mutable_alter_subscription_stmt();

  public:
  // .pg_query.DropSubscriptionStmt drop_subscription_stmt = 243 [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;
  PROTOBUF_NODISCARD ::pg_query::DropSubscriptionStmt* release_drop_subscription_stmt();
  ::pg_query::DropSubscriptionStmt* mutable_drop_subscription_stmt();
  void set_allocated_drop_subscription_stmt(::pg_query::DropSubscriptionStmt* value);
  void unsafe_arena_set_allocated_drop_subscription_stmt(::pg_query::DropSubscriptionStmt* value);
  ::pg_query::DropSubscriptionStmt* unsafe_arena_release_drop_subscription_stmt();

  private:
  const ::pg_query::DropSubscriptionStmt& _internal_drop_subscription_stmt() const;
  ::pg_query::DropSubscriptionStmt* _internal_mutable_drop_subscription_stmt();

  public:
  // .pg_query.Integer integer = 244 [json_name = "Integer"];
  bool has_integer() const;
  private:
  bool _internal_has_integer() const;

  public:
  void clear_integer() ;
  const ::pg_query::Integer& integer() const;
  PROTOBUF_NODISCARD ::pg_query::Integer* release_integer();
  ::pg_query::Integer* mutable_integer();
  void set_allocated_integer(::pg_query::Integer* value);
  void unsafe_arena_set_allocated_integer(::pg_query::Integer* value);
  ::pg_query::Integer* unsafe_arena_release_integer();

  private:
  const ::pg_query::Integer& _internal_integer() const;
  ::pg_query::Integer* _internal_mutable_integer();

  public:
  // .pg_query.Float float = 245 [json_name = "Float"];
  bool has_float_() const;
  private:
  bool _internal_has_float_() const;

  public:
  void clear_float_() ;
  const ::pg_query::Float& float_() const;
  PROTOBUF_NODISCARD ::pg_query::Float* release_float_();
  ::pg_query::Float* mutable_float_();
  void set_allocated_float_(::pg_query::Float* value);
  void unsafe_arena_set_allocated_float_(::pg_query::Float* value);
  ::pg_query::Float* unsafe_arena_release_float_();

  private:
  const ::pg_query::Float& _internal_float_() const;
  ::pg_query::Float* _internal_mutable_float_();

  public:
  // .pg_query.Boolean boolean = 246 [json_name = "Boolean"];
  bool has_boolean() const;
  private:
  bool _internal_has_boolean() const;

  public:
  void clear_boolean() ;
  const ::pg_query::Boolean& boolean() const;
  PROTOBUF_NODISCARD ::pg_query::Boolean* release_boolean();
  ::pg_query::Boolean* mutable_boolean();
  void set_allocated_boolean(::pg_query::Boolean* value);
  void unsafe_arena_set_allocated_boolean(::pg_query::Boolean* value);
  ::pg_query::Boolean* unsafe_arena_release_boolean();

  private:
  const ::pg_query::Boolean& _internal_boolean() const;
  ::pg_query::Boolean* _internal_mutable_boolean();

  public:
  // .pg_query.String string = 247 [json_name = "String"];
  bool has_string() const;
  private:
  bool _internal_has_string() const;

  public:
  void clear_string() ;
  const ::pg_query::String& string() const;
  PROTOBUF_NODISCARD ::pg_query::String* release_string();
  ::pg_query::String* mutable_string();
  void set_allocated_string(::pg_query::String* value);
  void unsafe_arena_set_allocated_string(::pg_query::String* value);
  ::pg_query::String* unsafe_arena_release_string();

  private:
  const ::pg_query::String& _internal_string() const;
  ::pg_query::String* _internal_mutable_string();

  public:
  // .pg_query.BitString bit_string = 248 [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;
  PROTOBUF_NODISCARD ::pg_query::BitString* release_bit_string();
  ::pg_query::BitString* mutable_bit_string();
  void set_allocated_bit_string(::pg_query::BitString* value);
  void unsafe_arena_set_allocated_bit_string(::pg_query::BitString* value);
  ::pg_query::BitString* unsafe_arena_release_bit_string();

  private:
  const ::pg_query::BitString& _internal_bit_string() const;
  ::pg_query::BitString* _internal_mutable_bit_string();

  public:
  // .pg_query.List list = 249 [json_name = "List"];
  bool has_list() const;
  private:
  bool _internal_has_list() const;

  public:
  void clear_list() ;
  const ::pg_query::List& list() const;
  PROTOBUF_NODISCARD ::pg_query::List* release_list();
  ::pg_query::List* mutable_list();
  void set_allocated_list(::pg_query::List* value);
  void unsafe_arena_set_allocated_list(::pg_query::List* value);
  ::pg_query::List* unsafe_arena_release_list();

  private:
  const ::pg_query::List& _internal_list() const;
  ::pg_query::List* _internal_mutable_list();

  public:
  // .pg_query.IntList int_list = 250 [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;
  PROTOBUF_NODISCARD ::pg_query::IntList* release_int_list();
  ::pg_query::IntList* mutable_int_list();
  void set_allocated_int_list(::pg_query::IntList* value);
  void unsafe_arena_set_allocated_int_list(::pg_query::IntList* value);
  ::pg_query::IntList* unsafe_arena_release_int_list();

  private:
  const ::pg_query::IntList& _internal_int_list() const;
  ::pg_query::IntList* _internal_mutable_int_list();

  public:
  // .pg_query.OidList oid_list = 251 [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;
  PROTOBUF_NODISCARD ::pg_query::OidList* release_oid_list();
  ::pg_query::OidList* mutable_oid_list();
  void set_allocated_oid_list(::pg_query::OidList* value);
  void unsafe_arena_set_allocated_oid_list(::pg_query::OidList* value);
  ::pg_query::OidList* unsafe_arena_release_oid_list();

  private:
  const ::pg_query::OidList& _internal_oid_list() const;
  ::pg_query::OidList* _internal_mutable_oid_list();

  public:
  // .pg_query.A_Const a_const = 252 [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;
  PROTOBUF_NODISCARD ::pg_query::A_Const* release_a_const();
  ::pg_query::A_Const* mutable_a_const();
  void set_allocated_a_const(::pg_query::A_Const* value);
  void unsafe_arena_set_allocated_a_const(::pg_query::A_Const* value);
  ::pg_query::A_Const* unsafe_arena_release_a_const();

  private:
  const ::pg_query::A_Const& _internal_a_const() const;
  ::pg_query::A_Const* _internal_mutable_a_const();

  public:
  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_into_clause();
  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_json_format();
  void set_has_json_returning();
  void set_has_json_value_expr();
  void set_has_json_constructor_expr();
  void set_has_json_is_predicate();
  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_query();
  void set_has_type_name();
  void set_has_column_ref();
  void set_has_param_ref();
  void set_has_a_expr();
  void set_has_type_cast();
  void set_has_collate_clause();
  void set_has_role_spec();
  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_sort_by();
  void set_has_window_def();
  void set_has_range_subselect();
  void set_has_range_function();
  void set_has_range_table_func();
  void set_has_range_table_func_col();
  void set_has_range_table_sample();
  void set_has_column_def();
  void set_has_table_like_clause();
  void set_has_index_elem();
  void set_has_def_elem();
  void set_has_locking_clause();
  void set_has_xml_serialize();
  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_range_tbl_entry();
  void set_has_rtepermission_info();
  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_row_mark_clause();
  void set_has_with_clause();
  void set_has_infer_clause();
  void set_has_on_conflict_clause();
  void set_has_ctesearch_clause();
  void set_has_ctecycle_clause();
  void set_has_common_table_expr();
  void set_has_merge_when_clause();
  void set_has_merge_action();
  void set_has_trigger_transition();
  void set_has_json_output();
  void set_has_json_key_value();
  void set_has_json_object_constructor();
  void set_has_json_array_constructor();
  void set_has_json_array_query_constructor();
  void set_has_json_agg_constructor();
  void set_has_json_object_agg();
  void set_has_json_array_agg();
  void set_has_raw_stmt();
  void set_has_insert_stmt();
  void set_has_delete_stmt();
  void set_has_update_stmt();
  void set_has_merge_stmt();
  void set_has_select_stmt();
  void set_has_set_operation_stmt();
  void set_has_return_stmt();
  void set_has_plassign_stmt();
  void set_has_create_schema_stmt();
  void set_has_alter_table_stmt();
  void set_has_replica_identity_stmt();
  void set_has_alter_table_cmd();
  void set_has_alter_collation_stmt();
  void set_has_alter_domain_stmt();
  void set_has_grant_stmt();
  void set_has_object_with_args();
  void set_has_access_priv();
  void set_has_grant_role_stmt();
  void set_has_alter_default_privileges_stmt();
  void set_has_copy_stmt();
  void set_has_variable_set_stmt();
  void set_has_variable_show_stmt();
  void set_has_create_stmt();
  void set_has_constraint();
  void set_has_create_table_space_stmt();
  void set_has_drop_table_space_stmt();
  void set_has_alter_table_space_options_stmt();
  void set_has_alter_table_move_all_stmt();
  void set_has_create_extension_stmt();
  void set_has_alter_extension_stmt();
  void set_has_alter_extension_contents_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_foreign_table_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_import_foreign_schema_stmt();
  void set_has_create_policy_stmt();
  void set_has_alter_policy_stmt();
  void set_has_create_am_stmt();
  void set_has_create_trig_stmt();
  void set_has_create_event_trig_stmt();
  void set_has_alter_event_trig_stmt();
  void set_has_create_plang_stmt();
  void set_has_create_role_stmt();
  void set_has_alter_role_stmt();
  void set_has_alter_role_set_stmt();
  void set_has_drop_role_stmt();
  void set_has_create_seq_stmt();
  void set_has_alter_seq_stmt();
  void set_has_define_stmt();
  void set_has_create_domain_stmt();
  void set_has_create_op_class_stmt();
  void set_has_create_op_class_item();
  void set_has_create_op_family_stmt();
  void set_has_alter_op_family_stmt();
  void set_has_drop_stmt();
  void set_has_truncate_stmt();
  void set_has_comment_stmt();
  void set_has_sec_label_stmt();
  void set_has_declare_cursor_stmt();
  void set_has_close_portal_stmt();
  void set_has_fetch_stmt();
  void set_has_index_stmt();
  void set_has_create_stats_stmt();
  void set_has_stats_elem();
  void set_has_alter_stats_stmt();
  void set_has_create_function_stmt();
  void set_has_function_parameter();
  void set_has_alter_function_stmt();
  void set_has_do_stmt();
  void set_has_inline_code_block();
  void set_has_call_stmt();
  void set_has_call_context();
  void set_has_rename_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_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_composite_type_stmt();
  void set_has_create_enum_stmt();
  void set_has_create_range_stmt();
  void set_has_alter_enum_stmt();
  void set_has_view_stmt();
  void set_has_load_stmt();
  void set_has_createdb_stmt();
  void set_has_alter_database_stmt();
  void set_has_alter_database_refresh_coll_stmt();
  void set_has_alter_database_set_stmt();
  void set_has_dropdb_stmt();
  void set_has_alter_system_stmt();
  void set_has_cluster_stmt();
  void set_has_vacuum_stmt();
  void set_has_vacuum_relation();
  void set_has_explain_stmt();
  void set_has_create_table_as_stmt();
  void set_has_refresh_mat_view_stmt();
  void set_has_check_point_stmt();
  void set_has_discard_stmt();
  void set_has_lock_stmt();
  void set_has_constraints_set_stmt();
  void set_has_reindex_stmt();
  void set_has_create_conversion_stmt();
  void set_has_create_cast_stmt();
  void set_has_create_transform_stmt();
  void set_has_prepare_stmt();
  void set_has_execute_stmt();
  void set_has_deallocate_stmt();
  void set_has_drop_owned_stmt();
  void set_has_reassign_owned_stmt();
  void set_has_alter_tsdictionary_stmt();
  void set_has_alter_tsconfiguration_stmt();
  void set_has_publication_table();
  void set_has_publication_obj_spec();
  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_integer();
  void set_has_float_();
  void set_has_boolean();
  void set_has_string();
  void set_has_bit_string();
  void set_has_list();
  void set_has_int_list();
  void set_has_oid_list();
  void set_has_a_const();

  inline bool has_node() const;
  inline void clear_has_node();

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 252, 252,
      0, 33>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    union NodeUnion {
      constexpr NodeUnion() : _constinit_{} {}
        ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::pg_query::Alias* alias_;
      ::pg_query::RangeVar* range_var_;
      ::pg_query::TableFunc* table_func_;
      ::pg_query::IntoClause* into_clause_;
      ::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::JsonFormat* json_format_;
      ::pg_query::JsonReturning* json_returning_;
      ::pg_query::JsonValueExpr* json_value_expr_;
      ::pg_query::JsonConstructorExpr* json_constructor_expr_;
      ::pg_query::JsonIsPredicate* json_is_predicate_;
      ::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::Query* query_;
      ::pg_query::TypeName* type_name_;
      ::pg_query::ColumnRef* column_ref_;
      ::pg_query::ParamRef* param_ref_;
      ::pg_query::A_Expr* a_expr_;
      ::pg_query::TypeCast* type_cast_;
      ::pg_query::CollateClause* collate_clause_;
      ::pg_query::RoleSpec* role_spec_;
      ::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::SortBy* sort_by_;
      ::pg_query::WindowDef* window_def_;
      ::pg_query::RangeSubselect* range_subselect_;
      ::pg_query::RangeFunction* range_function_;
      ::pg_query::RangeTableFunc* range_table_func_;
      ::pg_query::RangeTableFuncCol* range_table_func_col_;
      ::pg_query::RangeTableSample* range_table_sample_;
      ::pg_query::ColumnDef* column_def_;
      ::pg_query::TableLikeClause* table_like_clause_;
      ::pg_query::IndexElem* index_elem_;
      ::pg_query::DefElem* def_elem_;
      ::pg_query::LockingClause* locking_clause_;
      ::pg_query::XmlSerialize* xml_serialize_;
      ::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::RangeTblEntry* range_tbl_entry_;
      ::pg_query::RTEPermissionInfo* rtepermission_info_;
      ::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::RowMarkClause* row_mark_clause_;
      ::pg_query::WithClause* with_clause_;
      ::pg_query::InferClause* infer_clause_;
      ::pg_query::OnConflictClause* on_conflict_clause_;
      ::pg_query::CTESearchClause* ctesearch_clause_;
      ::pg_query::CTECycleClause* ctecycle_clause_;
      ::pg_query::CommonTableExpr* common_table_expr_;
      ::pg_query::MergeWhenClause* merge_when_clause_;
      ::pg_query::MergeAction* merge_action_;
      ::pg_query::TriggerTransition* trigger_transition_;
      ::pg_query::JsonOutput* json_output_;
      ::pg_query::JsonKeyValue* json_key_value_;
      ::pg_query::JsonObjectConstructor* json_object_constructor_;
      ::pg_query::JsonArrayConstructor* json_array_constructor_;
      ::pg_query::JsonArrayQueryConstructor* json_array_query_constructor_;
      ::pg_query::JsonAggConstructor* json_agg_constructor_;
      ::pg_query::JsonObjectAgg* json_object_agg_;
      ::pg_query::JsonArrayAgg* json_array_agg_;
      ::pg_query::RawStmt* raw_stmt_;
      ::pg_query::InsertStmt* insert_stmt_;
      ::pg_query::DeleteStmt* delete_stmt_;
      ::pg_query::UpdateStmt* update_stmt_;
      ::pg_query::MergeStmt* merge_stmt_;
      ::pg_query::SelectStmt* select_stmt_;
      ::pg_query::SetOperationStmt* set_operation_stmt_;
      ::pg_query::ReturnStmt* return_stmt_;
      ::pg_query::PLAssignStmt* plassign_stmt_;
      ::pg_query::CreateSchemaStmt* create_schema_stmt_;
      ::pg_query::AlterTableStmt* alter_table_stmt_;
      ::pg_query::ReplicaIdentityStmt* replica_identity_stmt_;
      ::pg_query::AlterTableCmd* alter_table_cmd_;
      ::pg_query::AlterCollationStmt* alter_collation_stmt_;
      ::pg_query::AlterDomainStmt* alter_domain_stmt_;
      ::pg_query::GrantStmt* grant_stmt_;
      ::pg_query::ObjectWithArgs* object_with_args_;
      ::pg_query::AccessPriv* access_priv_;
      ::pg_query::GrantRoleStmt* grant_role_stmt_;
      ::pg_query::AlterDefaultPrivilegesStmt* alter_default_privileges_stmt_;
      ::pg_query::CopyStmt* copy_stmt_;
      ::pg_query::VariableSetStmt* variable_set_stmt_;
      ::pg_query::VariableShowStmt* variable_show_stmt_;
      ::pg_query::CreateStmt* create_stmt_;
      ::pg_query::Constraint* constraint_;
      ::pg_query::CreateTableSpaceStmt* create_table_space_stmt_;
      ::pg_query::DropTableSpaceStmt* drop_table_space_stmt_;
      ::pg_query::AlterTableSpaceOptionsStmt* alter_table_space_options_stmt_;
      ::pg_query::AlterTableMoveAllStmt* alter_table_move_all_stmt_;
      ::pg_query::CreateExtensionStmt* create_extension_stmt_;
      ::pg_query::AlterExtensionStmt* alter_extension_stmt_;
      ::pg_query::AlterExtensionContentsStmt* alter_extension_contents_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::CreateForeignTableStmt* create_foreign_table_stmt_;
      ::pg_query::CreateUserMappingStmt* create_user_mapping_stmt_;
      ::pg_query::AlterUserMappingStmt* alter_user_mapping_stmt_;
      ::pg_query::DropUserMappingStmt* drop_user_mapping_stmt_;
      ::pg_query::ImportForeignSchemaStmt* import_foreign_schema_stmt_;
      ::pg_query::CreatePolicyStmt* create_policy_stmt_;
      ::pg_query::AlterPolicyStmt* alter_policy_stmt_;
      ::pg_query::CreateAmStmt* create_am_stmt_;
      ::pg_query::CreateTrigStmt* create_trig_stmt_;
      ::pg_query::CreateEventTrigStmt* create_event_trig_stmt_;
      ::pg_query::AlterEventTrigStmt* alter_event_trig_stmt_;
      ::pg_query::CreatePLangStmt* create_plang_stmt_;
      ::pg_query::CreateRoleStmt* create_role_stmt_;
      ::pg_query::AlterRoleStmt* alter_role_stmt_;
      ::pg_query::AlterRoleSetStmt* alter_role_set_stmt_;
      ::pg_query::DropRoleStmt* drop_role_stmt_;
      ::pg_query::CreateSeqStmt* create_seq_stmt_;
      ::pg_query::AlterSeqStmt* alter_seq_stmt_;
      ::pg_query::DefineStmt* define_stmt_;
      ::pg_query::CreateDomainStmt* create_domain_stmt_;
      ::pg_query::CreateOpClassStmt* create_op_class_stmt_;
      ::pg_query::CreateOpClassItem* create_op_class_item_;
      ::pg_query::CreateOpFamilyStmt* create_op_family_stmt_;
      ::pg_query::AlterOpFamilyStmt* alter_op_family_stmt_;
      ::pg_query::DropStmt* drop_stmt_;
      ::pg_query::TruncateStmt* truncate_stmt_;
      ::pg_query::CommentStmt* comment_stmt_;
      ::pg_query::SecLabelStmt* sec_label_stmt_;
      ::pg_query::DeclareCursorStmt* declare_cursor_stmt_;
      ::pg_query::ClosePortalStmt* close_portal_stmt_;
      ::pg_query::FetchStmt* fetch_stmt_;
      ::pg_query::IndexStmt* index_stmt_;
      ::pg_query::CreateStatsStmt* create_stats_stmt_;
      ::pg_query::StatsElem* stats_elem_;
      ::pg_query::AlterStatsStmt* alter_stats_stmt_;
      ::pg_query::CreateFunctionStmt* create_function_stmt_;
      ::pg_query::FunctionParameter* function_parameter_;
      ::pg_query::AlterFunctionStmt* alter_function_stmt_;
      ::pg_query::DoStmt* do_stmt_;
      ::pg_query::InlineCodeBlock* inline_code_block_;
      ::pg_query::CallStmt* call_stmt_;
      ::pg_query::CallContext* call_context_;
      ::pg_query::RenameStmt* rename_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::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::CompositeTypeStmt* composite_type_stmt_;
      ::pg_query::CreateEnumStmt* create_enum_stmt_;
      ::pg_query::CreateRangeStmt* create_range_stmt_;
      ::pg_query::AlterEnumStmt* alter_enum_stmt_;
      ::pg_query::ViewStmt* view_stmt_;
      ::pg_query::LoadStmt* load_stmt_;
      ::pg_query::CreatedbStmt* createdb_stmt_;
      ::pg_query::AlterDatabaseStmt* alter_database_stmt_;
      ::pg_query::AlterDatabaseRefreshCollStmt* alter_database_refresh_coll_stmt_;
      ::pg_query::AlterDatabaseSetStmt* alter_database_set_stmt_;
      ::pg_query::DropdbStmt* dropdb_stmt_;
      ::pg_query::AlterSystemStmt* alter_system_stmt_;
      ::pg_query::ClusterStmt* cluster_stmt_;
      ::pg_query::VacuumStmt* vacuum_stmt_;
      ::pg_query::VacuumRelation* vacuum_relation_;
      ::pg_query::ExplainStmt* explain_stmt_;
      ::pg_query::CreateTableAsStmt* create_table_as_stmt_;
      ::pg_query::RefreshMatViewStmt* refresh_mat_view_stmt_;
      ::pg_query::CheckPointStmt* check_point_stmt_;
      ::pg_query::DiscardStmt* discard_stmt_;
      ::pg_query::LockStmt* lock_stmt_;
      ::pg_query::ConstraintsSetStmt* constraints_set_stmt_;
      ::pg_query::ReindexStmt* reindex_stmt_;
      ::pg_query::CreateConversionStmt* create_conversion_stmt_;
      ::pg_query::CreateCastStmt* create_cast_stmt_;
      ::pg_query::CreateTransformStmt* create_transform_stmt_;
      ::pg_query::PrepareStmt* prepare_stmt_;
      ::pg_query::ExecuteStmt* execute_stmt_;
      ::pg_query::DeallocateStmt* deallocate_stmt_;
      ::pg_query::DropOwnedStmt* drop_owned_stmt_;
      ::pg_query::ReassignOwnedStmt* reassign_owned_stmt_;
      ::pg_query::AlterTSDictionaryStmt* alter_tsdictionary_stmt_;
      ::pg_query::AlterTSConfigurationStmt* alter_tsconfiguration_stmt_;
      ::pg_query::PublicationTable* publication_table_;
      ::pg_query::PublicationObjSpec* publication_obj_spec_;
      ::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::Integer* integer_;
      ::pg_query::Float* float__;
      ::pg_query::Boolean* boolean_;
      ::pg_query::String* string_;
      ::pg_query::BitString* bit_string_;
      ::pg_query::List* list_;
      ::pg_query::IntList* int_list_;
      ::pg_query::OidList* oid_list_;
      ::pg_query::A_Const* a_const_;
    } node_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class NullIfExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.NullIfExpr) */ {
 public:
  inline NullIfExpr() : NullIfExpr(nullptr) {}
  ~NullIfExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR NullIfExpr(::google::protobuf::internal::ConstantInitialized);

  inline NullIfExpr(const NullIfExpr& from)
      : NullIfExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NullIfExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NullIfExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  NullIfExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NullIfExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const NullIfExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const NullIfExpr& from) {
    NullIfExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(NullIfExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.NullIfExpr";
  }
  protected:
  explicit NullIfExpr(::google::protobuf::Arena* arena);
  NullIfExpr(::google::protobuf::Arena* arena, const NullIfExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kArgsFieldNumber = 7,
    kXprFieldNumber = 1,
    kOpnoFieldNumber = 2,
    kOpresulttypeFieldNumber = 3,
    kOpretsetFieldNumber = 4,
    kOpcollidFieldNumber = 5,
    kInputcollidFieldNumber = 6,
    kLocationFieldNumber = 8,
  };
  // repeated .pg_query.Node args = 7 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;

  public:
  void clear_args() ;
  ::pg_query::Node* mutable_args(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 opno = 2 [json_name = "opno"];
  void clear_opno() ;
  ::uint32_t opno() const;
  void set_opno(::uint32_t value);

  private:
  ::uint32_t _internal_opno() const;
  void _internal_set_opno(::uint32_t value);

  public:
  // uint32 opresulttype = 3 [json_name = "opresulttype"];
  void clear_opresulttype() ;
  ::uint32_t opresulttype() const;
  void set_opresulttype(::uint32_t value);

  private:
  ::uint32_t _internal_opresulttype() const;
  void _internal_set_opresulttype(::uint32_t value);

  public:
  // bool opretset = 4 [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 = 5 [json_name = "opcollid"];
  void clear_opcollid() ;
  ::uint32_t opcollid() const;
  void set_opcollid(::uint32_t value);

  private:
  ::uint32_t _internal_opcollid() const;
  void _internal_set_opcollid(::uint32_t value);

  public:
  // uint32 inputcollid = 6 [json_name = "inputcollid"];
  void clear_inputcollid() ;
  ::uint32_t inputcollid() const;
  void set_inputcollid(::uint32_t value);

  private:
  ::uint32_t _internal_inputcollid() const;
  void _internal_set_inputcollid(::uint32_t value);

  public:
  // int32 location = 8 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.NullIfExpr)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* xpr_;
    ::uint32_t opno_;
    ::uint32_t opresulttype_;
    bool opretset_;
    ::uint32_t opcollid_;
    ::uint32_t inputcollid_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class NullTest final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.NullTest) */ {
 public:
  inline NullTest() : NullTest(nullptr) {}
  ~NullTest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR NullTest(::google::protobuf::internal::ConstantInitialized);

  inline NullTest(const NullTest& from)
      : NullTest(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NullTest& default_instance() {
    return *internal_default_instance();
  }
  static inline const NullTest* internal_default_instance() {
    return reinterpret_cast<const NullTest*>(
               &_NullTest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    54;

  friend void swap(NullTest& a, NullTest& b) {
    a.Swap(&b);
  }
  inline void Swap(NullTest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NullTest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  NullTest* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NullTest>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const NullTest& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const NullTest& from) {
    NullTest::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(NullTest* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.NullTest";
  }
  protected:
  explicit NullTest(::google::protobuf::Arena* arena);
  NullTest(::google::protobuf::Arena* arena, const NullTest& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  void clear_arg() ;
  const ::pg_query::Node& arg() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* value);
  void unsafe_arena_set_allocated_arg(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_arg();

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // .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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.NullTest)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* arg_;
    int nulltesttype_;
    bool argisrow_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ObjectWithArgs final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ObjectWithArgs) */ {
 public:
  inline ObjectWithArgs() : ObjectWithArgs(nullptr) {}
  ~ObjectWithArgs() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ObjectWithArgs(::google::protobuf::internal::ConstantInitialized);

  inline ObjectWithArgs(const ObjectWithArgs& from)
      : ObjectWithArgs(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ObjectWithArgs& default_instance() {
    return *internal_default_instance();
  }
  static inline const ObjectWithArgs* internal_default_instance() {
    return reinterpret_cast<const ObjectWithArgs*>(
               &_ObjectWithArgs_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    142;

  friend void swap(ObjectWithArgs& a, ObjectWithArgs& b) {
    a.Swap(&b);
  }
  inline void Swap(ObjectWithArgs* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ObjectWithArgs* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ObjectWithArgs* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ObjectWithArgs>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ObjectWithArgs& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ObjectWithArgs& from) {
    ObjectWithArgs::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ObjectWithArgs* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ObjectWithArgs";
  }
  protected:
  explicit ObjectWithArgs(::google::protobuf::Arena* arena);
  ObjectWithArgs(::google::protobuf::Arena* arena, const ObjectWithArgs& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kObjnameFieldNumber = 1,
    kObjargsFieldNumber = 2,
    kObjfuncargsFieldNumber = 3,
    kArgsUnspecifiedFieldNumber = 4,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_objname();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_objname() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_objname();
  public:
  const ::pg_query::Node& objname(int index) const;
  ::pg_query::Node* add_objname();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_objargs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_objargs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_objargs();
  public:
  const ::pg_query::Node& objargs(int index) const;
  ::pg_query::Node* add_objargs();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      objargs() const;
  // repeated .pg_query.Node objfuncargs = 3 [json_name = "objfuncargs"];
  int objfuncargs_size() const;
  private:
  int _internal_objfuncargs_size() const;

  public:
  void clear_objfuncargs() ;
  ::pg_query::Node* mutable_objfuncargs(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_objfuncargs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_objfuncargs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_objfuncargs();
  public:
  const ::pg_query::Node& objfuncargs(int index) const;
  ::pg_query::Node* add_objfuncargs();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      objfuncargs() const;
  // bool args_unspecified = 4 [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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > objname_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > objargs_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > objfuncargs_;
    bool args_unspecified_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class OidList final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.OidList) */ {
 public:
  inline OidList() : OidList(nullptr) {}
  ~OidList() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR OidList(::google::protobuf::internal::ConstantInitialized);

  inline OidList(const OidList& from)
      : OidList(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OidList& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OidList* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  OidList* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OidList>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const OidList& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const OidList& from) {
    OidList::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(OidList* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.OidList";
  }
  protected:
  explicit OidList(::google::protobuf::Arena* arena);
  OidList(::google::protobuf::Arena* arena, const OidList& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_items();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_items() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_items();
  public:
  const ::pg_query::Node& items(int index) const;
  ::pg_query::Node* add_items();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      items() const;
  // @@protoc_insertion_point(class_scope:pg_query.OidList)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > items_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class OnConflictClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.OnConflictClause) */ {
 public:
  inline OnConflictClause() : OnConflictClause(nullptr) {}
  ~OnConflictClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR OnConflictClause(::google::protobuf::internal::ConstantInitialized);

  inline OnConflictClause(const OnConflictClause& from)
      : OnConflictClause(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OnConflictClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const OnConflictClause* internal_default_instance() {
    return reinterpret_cast<const OnConflictClause*>(
               &_OnConflictClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    111;

  friend void swap(OnConflictClause& a, OnConflictClause& b) {
    a.Swap(&b);
  }
  inline void Swap(OnConflictClause* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OnConflictClause* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  OnConflictClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OnConflictClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const OnConflictClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const OnConflictClause& from) {
    OnConflictClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(OnConflictClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.OnConflictClause";
  }
  protected:
  explicit OnConflictClause(::google::protobuf::Arena* arena);
  OnConflictClause(::google::protobuf::Arena* arena, const OnConflictClause& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_target_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_target_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_target_list();
  public:
  const ::pg_query::Node& target_list(int index) const;
  ::pg_query::Node* add_target_list();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      target_list() const;
  // .pg_query.InferClause infer = 2 [json_name = "infer"];
  bool has_infer() const;
  void clear_infer() ;
  const ::pg_query::InferClause& infer() const;
  PROTOBUF_NODISCARD ::pg_query::InferClause* release_infer();
  ::pg_query::InferClause* mutable_infer();
  void set_allocated_infer(::pg_query::InferClause* value);
  void unsafe_arena_set_allocated_infer(::pg_query::InferClause* value);
  ::pg_query::InferClause* unsafe_arena_release_infer();

  private:
  const ::pg_query::InferClause& _internal_infer() const;
  ::pg_query::InferClause* _internal_mutable_infer();

  public:
  // .pg_query.Node where_clause = 4 [json_name = "whereClause"];
  bool has_where_clause() const;
  void clear_where_clause() ;
  const ::pg_query::Node& where_clause() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* value);
  void unsafe_arena_set_allocated_where_clause(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();

  public:
  // .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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.OnConflictClause)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > target_list_;
    ::pg_query::InferClause* infer_;
    ::pg_query::Node* where_clause_;
    int action_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class OnConflictExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.OnConflictExpr) */ {
 public:
  inline OnConflictExpr() : OnConflictExpr(nullptr) {}
  ~OnConflictExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR OnConflictExpr(::google::protobuf::internal::ConstantInitialized);

  inline OnConflictExpr(const OnConflictExpr& from)
      : OnConflictExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OnConflictExpr& default_instance() {
    return *internal_default_instance();
  }
  static inline const OnConflictExpr* internal_default_instance() {
    return reinterpret_cast<const OnConflictExpr*>(
               &_OnConflictExpr_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    66;

  friend void swap(OnConflictExpr& a, OnConflictExpr& b) {
    a.Swap(&b);
  }
  inline void Swap(OnConflictExpr* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OnConflictExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  OnConflictExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OnConflictExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const OnConflictExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const OnConflictExpr& from) {
    OnConflictExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(OnConflictExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.OnConflictExpr";
  }
  protected:
  explicit OnConflictExpr(::google::protobuf::Arena* arena);
  OnConflictExpr(::google::protobuf::Arena* arena, const OnConflictExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_arbiter_elems();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_arbiter_elems() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_arbiter_elems();
  public:
  const ::pg_query::Node& arbiter_elems(int index) const;
  ::pg_query::Node* add_arbiter_elems();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_on_conflict_set();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_on_conflict_set() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_on_conflict_set();
  public:
  const ::pg_query::Node& on_conflict_set(int index) const;
  ::pg_query::Node* add_on_conflict_set();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_excl_rel_tlist();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_excl_rel_tlist() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_excl_rel_tlist();
  public:
  const ::pg_query::Node& excl_rel_tlist(int index) const;
  ::pg_query::Node* add_excl_rel_tlist();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      excl_rel_tlist() const;
  // .pg_query.Node arbiter_where = 3 [json_name = "arbiterWhere"];
  bool has_arbiter_where() const;
  void clear_arbiter_where() ;
  const ::pg_query::Node& arbiter_where() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_arbiter_where();
  ::pg_query::Node* mutable_arbiter_where();
  void set_allocated_arbiter_where(::pg_query::Node* value);
  void unsafe_arena_set_allocated_arbiter_where(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_arbiter_where();

  private:
  const ::pg_query::Node& _internal_arbiter_where() const;
  ::pg_query::Node* _internal_mutable_arbiter_where();

  public:
  // .pg_query.Node on_conflict_where = 6 [json_name = "onConflictWhere"];
  bool has_on_conflict_where() const;
  void clear_on_conflict_where() ;
  const ::pg_query::Node& on_conflict_where() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_on_conflict_where();
  ::pg_query::Node* mutable_on_conflict_where();
  void set_allocated_on_conflict_where(::pg_query::Node* value);
  void unsafe_arena_set_allocated_on_conflict_where(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_on_conflict_where();

  private:
  const ::pg_query::Node& _internal_on_conflict_where() const;
  ::pg_query::Node* _internal_mutable_on_conflict_where();

  public:
  // .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() ;
  ::uint32_t constraint() const;
  void set_constraint(::uint32_t value);

  private:
  ::uint32_t _internal_constraint() const;
  void _internal_set_constraint(::uint32_t value);

  public:
  // int32 excl_rel_index = 7 [json_name = "exclRelIndex"];
  void clear_excl_rel_index() ;
  ::int32_t excl_rel_index() const;
  void set_excl_rel_index(::int32_t value);

  private:
  ::int32_t _internal_excl_rel_index() const;
  void _internal_set_excl_rel_index(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.OnConflictExpr)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 5,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > arbiter_elems_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > on_conflict_set_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > excl_rel_tlist_;
    ::pg_query::Node* arbiter_where_;
    ::pg_query::Node* on_conflict_where_;
    int action_;
    ::uint32_t constraint_;
    ::int32_t excl_rel_index_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class OpExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.OpExpr) */ {
 public:
  inline OpExpr() : OpExpr(nullptr) {}
  ~OpExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR OpExpr(::google::protobuf::internal::ConstantInitialized);

  inline OpExpr(const OpExpr& from)
      : OpExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OpExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OpExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  OpExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OpExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const OpExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const OpExpr& from) {
    OpExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(OpExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.OpExpr";
  }
  protected:
  explicit OpExpr(::google::protobuf::Arena* arena);
  OpExpr(::google::protobuf::Arena* arena, const OpExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kArgsFieldNumber = 7,
    kXprFieldNumber = 1,
    kOpnoFieldNumber = 2,
    kOpresulttypeFieldNumber = 3,
    kOpretsetFieldNumber = 4,
    kOpcollidFieldNumber = 5,
    kInputcollidFieldNumber = 6,
    kLocationFieldNumber = 8,
  };
  // repeated .pg_query.Node args = 7 [json_name = "args"];
  int args_size() const;
  private:
  int _internal_args_size() const;

  public:
  void clear_args() ;
  ::pg_query::Node* mutable_args(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 opno = 2 [json_name = "opno"];
  void clear_opno() ;
  ::uint32_t opno() const;
  void set_opno(::uint32_t value);

  private:
  ::uint32_t _internal_opno() const;
  void _internal_set_opno(::uint32_t value);

  public:
  // uint32 opresulttype = 3 [json_name = "opresulttype"];
  void clear_opresulttype() ;
  ::uint32_t opresulttype() const;
  void set_opresulttype(::uint32_t value);

  private:
  ::uint32_t _internal_opresulttype() const;
  void _internal_set_opresulttype(::uint32_t value);

  public:
  // bool opretset = 4 [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 = 5 [json_name = "opcollid"];
  void clear_opcollid() ;
  ::uint32_t opcollid() const;
  void set_opcollid(::uint32_t value);

  private:
  ::uint32_t _internal_opcollid() const;
  void _internal_set_opcollid(::uint32_t value);

  public:
  // uint32 inputcollid = 6 [json_name = "inputcollid"];
  void clear_inputcollid() ;
  ::uint32_t inputcollid() const;
  void set_inputcollid(::uint32_t value);

  private:
  ::uint32_t _internal_inputcollid() const;
  void _internal_set_inputcollid(::uint32_t value);

  public:
  // int32 location = 8 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.OpExpr)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* xpr_;
    ::uint32_t opno_;
    ::uint32_t opresulttype_;
    bool opretset_;
    ::uint32_t opcollid_;
    ::uint32_t inputcollid_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class PLAssignStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.PLAssignStmt) */ {
 public:
  inline PLAssignStmt() : PLAssignStmt(nullptr) {}
  ~PLAssignStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PLAssignStmt(::google::protobuf::internal::ConstantInitialized);

  inline PLAssignStmt(const PLAssignStmt& from)
      : PLAssignStmt(nullptr, from) {}
  PLAssignStmt(PLAssignStmt&& from) noexcept
    : PLAssignStmt() {
    *this = ::std::move(from);
  }

  inline PLAssignStmt& operator=(const PLAssignStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline PLAssignStmt& operator=(PLAssignStmt&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PLAssignStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const PLAssignStmt* internal_default_instance() {
    return reinterpret_cast<const PLAssignStmt*>(
               &_PLAssignStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    134;

  friend void swap(PLAssignStmt& a, PLAssignStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(PLAssignStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PLAssignStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PLAssignStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PLAssignStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const PLAssignStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const PLAssignStmt& from) {
    PLAssignStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(PLAssignStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.PLAssignStmt";
  }
  protected:
  explicit PLAssignStmt(::google::protobuf::Arena* arena);
  PLAssignStmt(::google::protobuf::Arena* arena, const PLAssignStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIndirectionFieldNumber = 2,
    kNameFieldNumber = 1,
    kValFieldNumber = 4,
    kNnamesFieldNumber = 3,
    kLocationFieldNumber = 5,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_indirection();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_indirection() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_indirection();
  public:
  const ::pg_query::Node& indirection(int index) const;
  ::pg_query::Node* add_indirection();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      indirection() const;
  // string name = 1 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .pg_query.SelectStmt val = 4 [json_name = "val"];
  bool has_val() const;
  void clear_val() ;
  const ::pg_query::SelectStmt& val() const;
  PROTOBUF_NODISCARD ::pg_query::SelectStmt* release_val();
  ::pg_query::SelectStmt* mutable_val();
  void set_allocated_val(::pg_query::SelectStmt* value);
  void unsafe_arena_set_allocated_val(::pg_query::SelectStmt* value);
  ::pg_query::SelectStmt* unsafe_arena_release_val();

  private:
  const ::pg_query::SelectStmt& _internal_val() const;
  ::pg_query::SelectStmt* _internal_mutable_val();

  public:
  // int32 nnames = 3 [json_name = "nnames"];
  void clear_nnames() ;
  ::int32_t nnames() const;
  void set_nnames(::int32_t value);

  private:
  ::int32_t _internal_nnames() const;
  void _internal_set_nnames(::int32_t value);

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.PLAssignStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      34, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > indirection_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::pg_query::SelectStmt* val_;
    ::int32_t nnames_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class Param final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.Param) */ {
 public:
  inline Param() : Param(nullptr) {}
  ~Param() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Param(::google::protobuf::internal::ConstantInitialized);

  inline Param(const Param& from)
      : Param(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Param& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Param* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Param* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Param>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Param& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const Param& from) {
    Param::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(Param* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.Param";
  }
  protected:
  explicit Param(::google::protobuf::Arena* arena);
  Param(::google::protobuf::Arena* arena, const Param& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .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() ;
  ::int32_t paramid() const;
  void set_paramid(::int32_t value);

  private:
  ::int32_t _internal_paramid() const;
  void _internal_set_paramid(::int32_t value);

  public:
  // uint32 paramtype = 4 [json_name = "paramtype"];
  void clear_paramtype() ;
  ::uint32_t paramtype() const;
  void set_paramtype(::uint32_t value);

  private:
  ::uint32_t _internal_paramtype() const;
  void _internal_set_paramtype(::uint32_t value);

  public:
  // int32 paramtypmod = 5 [json_name = "paramtypmod"];
  void clear_paramtypmod() ;
  ::int32_t paramtypmod() const;
  void set_paramtypmod(::int32_t value);

  private:
  ::int32_t _internal_paramtypmod() const;
  void _internal_set_paramtypmod(::int32_t value);

  public:
  // uint32 paramcollid = 6 [json_name = "paramcollid"];
  void clear_paramcollid() ;
  ::uint32_t paramcollid() const;
  void set_paramcollid(::uint32_t value);

  private:
  ::uint32_t _internal_paramcollid() const;
  void _internal_set_paramcollid(::uint32_t value);

  public:
  // int32 location = 7 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.Param)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    int paramkind_;
    ::int32_t paramid_;
    ::uint32_t paramtype_;
    ::int32_t paramtypmod_;
    ::uint32_t paramcollid_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class PartitionBoundSpec final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionBoundSpec) */ {
 public:
  inline PartitionBoundSpec() : PartitionBoundSpec(nullptr) {}
  ~PartitionBoundSpec() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PartitionBoundSpec(::google::protobuf::internal::ConstantInitialized);

  inline PartitionBoundSpec(const PartitionBoundSpec& from)
      : PartitionBoundSpec(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PartitionBoundSpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const PartitionBoundSpec* internal_default_instance() {
    return reinterpret_cast<const PartitionBoundSpec*>(
               &_PartitionBoundSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    97;

  friend void swap(PartitionBoundSpec& a, PartitionBoundSpec& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionBoundSpec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartitionBoundSpec* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PartitionBoundSpec* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PartitionBoundSpec>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const PartitionBoundSpec& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const PartitionBoundSpec& from) {
    PartitionBoundSpec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(PartitionBoundSpec* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.PartitionBoundSpec";
  }
  protected:
  explicit PartitionBoundSpec(::google::protobuf::Arena* arena);
  PartitionBoundSpec(::google::protobuf::Arena* arena, const PartitionBoundSpec& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_listdatums();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_listdatums() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_listdatums();
  public:
  const ::pg_query::Node& listdatums(int index) const;
  ::pg_query::Node* add_listdatums();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_lowerdatums();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_lowerdatums() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_lowerdatums();
  public:
  const ::pg_query::Node& lowerdatums(int index) const;
  ::pg_query::Node* add_lowerdatums();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_upperdatums();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_upperdatums() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_upperdatums();
  public:
  const ::pg_query::Node& upperdatums(int index) const;
  ::pg_query::Node* add_upperdatums();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      upperdatums() const;
  // string strategy = 1 [json_name = "strategy"];
  void clear_strategy() ;
  const std::string& strategy() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_strategy(Arg_&& arg, Args_... args);
  std::string* mutable_strategy();
  PROTOBUF_NODISCARD std::string* release_strategy();
  void set_allocated_strategy(std::string* value);

  private:
  const std::string& _internal_strategy() const;
  inline PROTOBUF_ALWAYS_INLINE 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() ;
  ::int32_t modulus() const;
  void set_modulus(::int32_t value);

  private:
  ::int32_t _internal_modulus() const;
  void _internal_set_modulus(::int32_t value);

  public:
  // int32 remainder = 4 [json_name = "remainder"];
  void clear_remainder() ;
  ::int32_t remainder() const;
  void set_remainder(::int32_t value);

  private:
  ::int32_t _internal_remainder() const;
  void _internal_set_remainder(::int32_t value);

  public:
  // int32 location = 8 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.PartitionBoundSpec)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 3,
      52, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > listdatums_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > lowerdatums_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > upperdatums_;
    ::google::protobuf::internal::ArenaStringPtr strategy_;
    bool is_default_;
    ::int32_t modulus_;
    ::int32_t remainder_;
    ::int32_t location_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class PartitionCmd final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionCmd) */ {
 public:
  inline PartitionCmd() : PartitionCmd(nullptr) {}
  ~PartitionCmd() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PartitionCmd(::google::protobuf::internal::ConstantInitialized);

  inline PartitionCmd(const PartitionCmd& from)
      : PartitionCmd(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PartitionCmd& default_instance() {
    return *internal_default_instance();
  }
  static inline const PartitionCmd* internal_default_instance() {
    return reinterpret_cast<const PartitionCmd*>(
               &_PartitionCmd_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    99;

  friend void swap(PartitionCmd& a, PartitionCmd& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionCmd* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartitionCmd* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PartitionCmd* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PartitionCmd>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const PartitionCmd& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const PartitionCmd& from) {
    PartitionCmd::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(PartitionCmd* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.PartitionCmd";
  }
  protected:
  explicit PartitionCmd(::google::protobuf::Arena* arena);
  PartitionCmd(::google::protobuf::Arena* arena, const PartitionCmd& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kBoundFieldNumber = 2,
    kConcurrentFieldNumber = 3,
  };
  // .pg_query.RangeVar name = 1 [json_name = "name"];
  bool has_name() const;
  void clear_name() ;
  const ::pg_query::RangeVar& name() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_name();
  ::pg_query::RangeVar* mutable_name();
  void set_allocated_name(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_name(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_name();

  private:
  const ::pg_query::RangeVar& _internal_name() const;
  ::pg_query::RangeVar* _internal_mutable_name();

  public:
  // .pg_query.PartitionBoundSpec bound = 2 [json_name = "bound"];
  bool has_bound() const;
  void clear_bound() ;
  const ::pg_query::PartitionBoundSpec& bound() const;
  PROTOBUF_NODISCARD ::pg_query::PartitionBoundSpec* release_bound();
  ::pg_query::PartitionBoundSpec* mutable_bound();
  void set_allocated_bound(::pg_query::PartitionBoundSpec* value);
  void unsafe_arena_set_allocated_bound(::pg_query::PartitionBoundSpec* value);
  ::pg_query::PartitionBoundSpec* unsafe_arena_release_bound();

  private:
  const ::pg_query::PartitionBoundSpec& _internal_bound() const;
  ::pg_query::PartitionBoundSpec* _internal_mutable_bound();

  public:
  // bool concurrent = 3 [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.PartitionCmd)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::RangeVar* name_;
    ::pg_query::PartitionBoundSpec* bound_;
    bool concurrent_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class PartitionElem final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionElem) */ {
 public:
  inline PartitionElem() : PartitionElem(nullptr) {}
  ~PartitionElem() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PartitionElem(::google::protobuf::internal::ConstantInitialized);

  inline PartitionElem(const PartitionElem& from)
      : PartitionElem(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PartitionElem& default_instance() {
    return *internal_default_instance();
  }
  static inline const PartitionElem* internal_default_instance() {
    return reinterpret_cast<const PartitionElem*>(
               &_PartitionElem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    95;

  friend void swap(PartitionElem& a, PartitionElem& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionElem* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartitionElem* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PartitionElem* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PartitionElem>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const PartitionElem& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const PartitionElem& from) {
    PartitionElem::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(PartitionElem* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.PartitionElem";
  }
  protected:
  explicit PartitionElem(::google::protobuf::Arena* arena);
  PartitionElem(::google::protobuf::Arena* arena, const PartitionElem& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_collation();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_collation() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_collation();
  public:
  const ::pg_query::Node& collation(int index) const;
  ::pg_query::Node* add_collation();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_opclass();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_opclass() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_opclass();
  public:
  const ::pg_query::Node& opclass(int index) const;
  ::pg_query::Node* add_opclass();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      opclass() const;
  // string name = 1 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .pg_query.Node expr = 2 [json_name = "expr"];
  bool has_expr() const;
  void clear_expr() ;
  const ::pg_query::Node& expr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_expr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_expr();

  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.PartitionElem)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 3,
      35, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > collation_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > opclass_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::pg_query::Node* expr_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class PartitionRangeDatum final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionRangeDatum) */ {
 public:
  inline PartitionRangeDatum() : PartitionRangeDatum(nullptr) {}
  ~PartitionRangeDatum() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PartitionRangeDatum(::google::protobuf::internal::ConstantInitialized);

  inline PartitionRangeDatum(const PartitionRangeDatum& from)
      : PartitionRangeDatum(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PartitionRangeDatum& default_instance() {
    return *internal_default_instance();
  }
  static inline const PartitionRangeDatum* internal_default_instance() {
    return reinterpret_cast<const PartitionRangeDatum*>(
               &_PartitionRangeDatum_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    98;

  friend void swap(PartitionRangeDatum& a, PartitionRangeDatum& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionRangeDatum* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartitionRangeDatum* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PartitionRangeDatum* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PartitionRangeDatum>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const PartitionRangeDatum& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const PartitionRangeDatum& from) {
    PartitionRangeDatum::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(PartitionRangeDatum* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.PartitionRangeDatum";
  }
  protected:
  explicit PartitionRangeDatum(::google::protobuf::Arena* arena);
  PartitionRangeDatum(::google::protobuf::Arena* arena, const PartitionRangeDatum& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValueFieldNumber = 2,
    kKindFieldNumber = 1,
    kLocationFieldNumber = 3,
  };
  // .pg_query.Node value = 2 [json_name = "value"];
  bool has_value() const;
  void clear_value() ;
  const ::pg_query::Node& value() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_value();
  ::pg_query::Node* mutable_value();
  void set_allocated_value(::pg_query::Node* value);
  void unsafe_arena_set_allocated_value(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_value();

  private:
  const ::pg_query::Node& _internal_value() const;
  ::pg_query::Node* _internal_mutable_value();

  public:
  // .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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.PartitionRangeDatum)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* value_;
    int kind_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class PartitionSpec final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionSpec) */ {
 public:
  inline PartitionSpec() : PartitionSpec(nullptr) {}
  ~PartitionSpec() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PartitionSpec(::google::protobuf::internal::ConstantInitialized);

  inline PartitionSpec(const PartitionSpec& from)
      : PartitionSpec(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PartitionSpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const PartitionSpec* internal_default_instance() {
    return reinterpret_cast<const PartitionSpec*>(
               &_PartitionSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    96;

  friend void swap(PartitionSpec& a, PartitionSpec& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionSpec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartitionSpec* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PartitionSpec* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PartitionSpec>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const PartitionSpec& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const PartitionSpec& from) {
    PartitionSpec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(PartitionSpec* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.PartitionSpec";
  }
  protected:
  explicit PartitionSpec(::google::protobuf::Arena* arena);
  PartitionSpec(::google::protobuf::Arena* arena, const PartitionSpec& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_part_params();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_part_params() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_part_params();
  public:
  const ::pg_query::Node& part_params(int index) const;
  ::pg_query::Node* add_part_params();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      part_params() const;
  // .pg_query.PartitionStrategy strategy = 1 [json_name = "strategy"];
  void clear_strategy() ;
  ::pg_query::PartitionStrategy strategy() const;
  void set_strategy(::pg_query::PartitionStrategy value);

  private:
  ::pg_query::PartitionStrategy _internal_strategy() const;
  void _internal_set_strategy(::pg_query::PartitionStrategy value);

  public:
  // int32 location = 3 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.PartitionSpec)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > part_params_;
    int strategy_;
    ::int32_t location_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class PrepareStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.PrepareStmt) */ {
 public:
  inline PrepareStmt() : PrepareStmt(nullptr) {}
  ~PrepareStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PrepareStmt(::google::protobuf::internal::ConstantInitialized);

  inline PrepareStmt(const PrepareStmt& from)
      : PrepareStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PrepareStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const PrepareStmt* internal_default_instance() {
    return reinterpret_cast<const PrepareStmt*>(
               &_PrepareStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    241;

  friend void swap(PrepareStmt& a, PrepareStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(PrepareStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PrepareStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PrepareStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PrepareStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const PrepareStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const PrepareStmt& from) {
    PrepareStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(PrepareStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.PrepareStmt";
  }
  protected:
  explicit PrepareStmt(::google::protobuf::Arena* arena);
  PrepareStmt(::google::protobuf::Arena* arena, const PrepareStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_argtypes();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_argtypes() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_argtypes();
  public:
  const ::pg_query::Node& argtypes(int index) const;
  ::pg_query::Node* add_argtypes();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      argtypes() const;
  // string name = 1 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .pg_query.Node query = 3 [json_name = "query"];
  bool has_query() const;
  void clear_query() ;
  const ::pg_query::Node& query() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* value);
  void unsafe_arena_set_allocated_query(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_query();

  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();

  public:
  // @@protoc_insertion_point(class_scope:pg_query.PrepareStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      33, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > argtypes_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::pg_query::Node* query_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class PublicationObjSpec final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.PublicationObjSpec) */ {
 public:
  inline PublicationObjSpec() : PublicationObjSpec(nullptr) {}
  ~PublicationObjSpec() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PublicationObjSpec(::google::protobuf::internal::ConstantInitialized);

  inline PublicationObjSpec(const PublicationObjSpec& from)
      : PublicationObjSpec(nullptr, from) {}
  PublicationObjSpec(PublicationObjSpec&& from) noexcept
    : PublicationObjSpec() {
    *this = ::std::move(from);
  }

  inline PublicationObjSpec& operator=(const PublicationObjSpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline PublicationObjSpec& operator=(PublicationObjSpec&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PublicationObjSpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const PublicationObjSpec* internal_default_instance() {
    return reinterpret_cast<const PublicationObjSpec*>(
               &_PublicationObjSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    249;

  friend void swap(PublicationObjSpec& a, PublicationObjSpec& b) {
    a.Swap(&b);
  }
  inline void Swap(PublicationObjSpec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PublicationObjSpec* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PublicationObjSpec* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PublicationObjSpec>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const PublicationObjSpec& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const PublicationObjSpec& from) {
    PublicationObjSpec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(PublicationObjSpec* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.PublicationObjSpec";
  }
  protected:
  explicit PublicationObjSpec(::google::protobuf::Arena* arena);
  PublicationObjSpec(::google::protobuf::Arena* arena, const PublicationObjSpec& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 2,
    kPubtableFieldNumber = 3,
    kPubobjtypeFieldNumber = 1,
    kLocationFieldNumber = 4,
  };
  // string name = 2 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .pg_query.PublicationTable pubtable = 3 [json_name = "pubtable"];
  bool has_pubtable() const;
  void clear_pubtable() ;
  const ::pg_query::PublicationTable& pubtable() const;
  PROTOBUF_NODISCARD ::pg_query::PublicationTable* release_pubtable();
  ::pg_query::PublicationTable* mutable_pubtable();
  void set_allocated_pubtable(::pg_query::PublicationTable* value);
  void unsafe_arena_set_allocated_pubtable(::pg_query::PublicationTable* value);
  ::pg_query::PublicationTable* unsafe_arena_release_pubtable();

  private:
  const ::pg_query::PublicationTable& _internal_pubtable() const;
  ::pg_query::PublicationTable* _internal_mutable_pubtable();

  public:
  // .pg_query.PublicationObjSpecType pubobjtype = 1 [json_name = "pubobjtype"];
  void clear_pubobjtype() ;
  ::pg_query::PublicationObjSpecType pubobjtype() const;
  void set_pubobjtype(::pg_query::PublicationObjSpecType value);

  private:
  ::pg_query::PublicationObjSpecType _internal_pubobjtype() const;
  void _internal_set_pubobjtype(::pg_query::PublicationObjSpecType value);

  public:
  // int32 location = 4 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.PublicationObjSpec)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 1,
      40, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::pg_query::PublicationTable* pubtable_;
    int pubobjtype_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class PublicationTable final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.PublicationTable) */ {
 public:
  inline PublicationTable() : PublicationTable(nullptr) {}
  ~PublicationTable() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PublicationTable(::google::protobuf::internal::ConstantInitialized);

  inline PublicationTable(const PublicationTable& from)
      : PublicationTable(nullptr, from) {}
  PublicationTable(PublicationTable&& from) noexcept
    : PublicationTable() {
    *this = ::std::move(from);
  }

  inline PublicationTable& operator=(const PublicationTable& from) {
    CopyFrom(from);
    return *this;
  }
  inline PublicationTable& operator=(PublicationTable&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PublicationTable& default_instance() {
    return *internal_default_instance();
  }
  static inline const PublicationTable* internal_default_instance() {
    return reinterpret_cast<const PublicationTable*>(
               &_PublicationTable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    248;

  friend void swap(PublicationTable& a, PublicationTable& b) {
    a.Swap(&b);
  }
  inline void Swap(PublicationTable* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PublicationTable* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PublicationTable* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PublicationTable>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const PublicationTable& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const PublicationTable& from) {
    PublicationTable::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(PublicationTable* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.PublicationTable";
  }
  protected:
  explicit PublicationTable(::google::protobuf::Arena* arena);
  PublicationTable(::google::protobuf::Arena* arena, const PublicationTable& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kColumnsFieldNumber = 3,
    kRelationFieldNumber = 1,
    kWhereClauseFieldNumber = 2,
  };
  // repeated .pg_query.Node columns = 3 [json_name = "columns"];
  int columns_size() const;
  private:
  int _internal_columns_size() const;

  public:
  void clear_columns() ;
  ::pg_query::Node* mutable_columns(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_columns();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_columns() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_columns();
  public:
  const ::pg_query::Node& columns(int index) const;
  ::pg_query::Node* add_columns();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      columns() const;
  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node where_clause = 2 [json_name = "whereClause"];
  bool has_where_clause() const;
  void clear_where_clause() ;
  const ::pg_query::Node& where_clause() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* value);
  void unsafe_arena_set_allocated_where_clause(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();

  public:
  // @@protoc_insertion_point(class_scope:pg_query.PublicationTable)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > columns_;
    ::pg_query::RangeVar* relation_;
    ::pg_query::Node* where_clause_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class Query final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.Query) */ {
 public:
  inline Query() : Query(nullptr) {}
  ~Query() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Query(::google::protobuf::internal::ConstantInitialized);

  inline Query(const Query& from)
      : Query(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Query& default_instance() {
    return *internal_default_instance();
  }
  static inline const Query* internal_default_instance() {
    return reinterpret_cast<const Query*>(
               &_Query_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    67;

  friend void swap(Query& a, Query& b) {
    a.Swap(&b);
  }
  inline void Swap(Query* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Query* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Query* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Query>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Query& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const Query& from) {
    Query::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(Query* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.Query";
  }
  protected:
  explicit Query(::google::protobuf::Arena* arena);
  Query(::google::protobuf::Arena* arena, const Query& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCteListFieldNumber = 16,
    kRtableFieldNumber = 17,
    kRteperminfosFieldNumber = 18,
    kMergeActionListFieldNumber = 20,
    kTargetListFieldNumber = 22,
    kReturningListFieldNumber = 25,
    kGroupClauseFieldNumber = 26,
    kGroupingSetsFieldNumber = 28,
    kWindowClauseFieldNumber = 30,
    kDistinctClauseFieldNumber = 31,
    kSortClauseFieldNumber = 32,
    kRowMarksFieldNumber = 36,
    kConstraintDepsFieldNumber = 38,
    kWithCheckOptionsFieldNumber = 39,
    kUtilityStmtFieldNumber = 4,
    kJointreeFieldNumber = 19,
    kOnConflictFieldNumber = 24,
    kHavingQualFieldNumber = 29,
    kLimitOffsetFieldNumber = 33,
    kLimitCountFieldNumber = 34,
    kSetOperationsFieldNumber = 37,
    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,
    kIsReturnFieldNumber = 15,
    kMergeUseOuterJoinFieldNumber = 21,
    kOverrideFieldNumber = 23,
    kGroupDistinctFieldNumber = 27,
    kLimitOptionFieldNumber = 35,
    kStmtLocationFieldNumber = 40,
    kStmtLenFieldNumber = 41,
  };
  // repeated .pg_query.Node cte_list = 16 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_cte_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_cte_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_cte_list();
  public:
  const ::pg_query::Node& cte_list(int index) const;
  ::pg_query::Node* add_cte_list();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      cte_list() const;
  // repeated .pg_query.Node rtable = 17 [json_name = "rtable"];
  int rtable_size() const;
  private:
  int _internal_rtable_size() const;

  public:
  void clear_rtable() ;
  ::pg_query::Node* mutable_rtable(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_rtable();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_rtable() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_rtable();
  public:
  const ::pg_query::Node& rtable(int index) const;
  ::pg_query::Node* add_rtable();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      rtable() const;
  // repeated .pg_query.Node rteperminfos = 18 [json_name = "rteperminfos"];
  int rteperminfos_size() const;
  private:
  int _internal_rteperminfos_size() const;

  public:
  void clear_rteperminfos() ;
  ::pg_query::Node* mutable_rteperminfos(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_rteperminfos();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_rteperminfos() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_rteperminfos();
  public:
  const ::pg_query::Node& rteperminfos(int index) const;
  ::pg_query::Node* add_rteperminfos();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      rteperminfos() const;
  // repeated .pg_query.Node merge_action_list = 20 [json_name = "mergeActionList"];
  int merge_action_list_size() const;
  private:
  int _internal_merge_action_list_size() const;

  public:
  void clear_merge_action_list() ;
  ::pg_query::Node* mutable_merge_action_list(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_merge_action_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_merge_action_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_merge_action_list();
  public:
  const ::pg_query::Node& merge_action_list(int index) const;
  ::pg_query::Node* add_merge_action_list();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      merge_action_list() const;
  // repeated .pg_query.Node target_list = 22 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_target_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_target_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_target_list();
  public:
  const ::pg_query::Node& target_list(int index) const;
  ::pg_query::Node* add_target_list();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      target_list() const;
  // repeated .pg_query.Node returning_list = 25 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_returning_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_returning_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_returning_list();
  public:
  const ::pg_query::Node& returning_list(int index) const;
  ::pg_query::Node* add_returning_list();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      returning_list() const;
  // repeated .pg_query.Node group_clause = 26 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_group_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_group_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_group_clause();
  public:
  const ::pg_query::Node& group_clause(int index) const;
  ::pg_query::Node* add_group_clause();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      group_clause() const;
  // repeated .pg_query.Node grouping_sets = 28 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_grouping_sets();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_grouping_sets() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_grouping_sets();
  public:
  const ::pg_query::Node& grouping_sets(int index) const;
  ::pg_query::Node* add_grouping_sets();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      grouping_sets() const;
  // repeated .pg_query.Node window_clause = 30 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_window_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_window_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_window_clause();
  public:
  const ::pg_query::Node& window_clause(int index) const;
  ::pg_query::Node* add_window_clause();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      window_clause() const;
  // repeated .pg_query.Node distinct_clause = 31 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_distinct_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_distinct_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_distinct_clause();
  public:
  const ::pg_query::Node& distinct_clause(int index) const;
  ::pg_query::Node* add_distinct_clause();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      distinct_clause() const;
  // repeated .pg_query.Node sort_clause = 32 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_sort_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_sort_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_sort_clause();
  public:
  const ::pg_query::Node& sort_clause(int index) const;
  ::pg_query::Node* add_sort_clause();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      sort_clause() const;
  // repeated .pg_query.Node row_marks = 36 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_row_marks();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_row_marks() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_row_marks();
  public:
  const ::pg_query::Node& row_marks(int index) const;
  ::pg_query::Node* add_row_marks();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      row_marks() const;
  // repeated .pg_query.Node constraint_deps = 38 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_constraint_deps();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_constraint_deps() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_constraint_deps();
  public:
  const ::pg_query::Node& constraint_deps(int index) const;
  ::pg_query::Node* add_constraint_deps();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      constraint_deps() const;
  // repeated .pg_query.Node with_check_options = 39 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_with_check_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_with_check_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_with_check_options();
  public:
  const ::pg_query::Node& with_check_options(int index) const;
  ::pg_query::Node* add_with_check_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      with_check_options() const;
  // .pg_query.Node utility_stmt = 4 [json_name = "utilityStmt"];
  bool has_utility_stmt() const;
  void clear_utility_stmt() ;
  const ::pg_query::Node& utility_stmt() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_utility_stmt();
  ::pg_query::Node* mutable_utility_stmt();
  void set_allocated_utility_stmt(::pg_query::Node* value);
  void unsafe_arena_set_allocated_utility_stmt(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_utility_stmt();

  private:
  const ::pg_query::Node& _internal_utility_stmt() const;
  ::pg_query::Node* _internal_mutable_utility_stmt();

  public:
  // .pg_query.FromExpr jointree = 19 [json_name = "jointree"];
  bool has_jointree() const;
  void clear_jointree() ;
  const ::pg_query::FromExpr& jointree() const;
  PROTOBUF_NODISCARD ::pg_query::FromExpr* release_jointree();
  ::pg_query::FromExpr* mutable_jointree();
  void set_allocated_jointree(::pg_query::FromExpr* value);
  void unsafe_arena_set_allocated_jointree(::pg_query::FromExpr* value);
  ::pg_query::FromExpr* unsafe_arena_release_jointree();

  private:
  const ::pg_query::FromExpr& _internal_jointree() const;
  ::pg_query::FromExpr* _internal_mutable_jointree();

  public:
  // .pg_query.OnConflictExpr on_conflict = 24 [json_name = "onConflict"];
  bool has_on_conflict() const;
  void clear_on_conflict() ;
  const ::pg_query::OnConflictExpr& on_conflict() const;
  PROTOBUF_NODISCARD ::pg_query::OnConflictExpr* release_on_conflict();
  ::pg_query::OnConflictExpr* mutable_on_conflict();
  void set_allocated_on_conflict(::pg_query::OnConflictExpr* value);
  void unsafe_arena_set_allocated_on_conflict(::pg_query::OnConflictExpr* value);
  ::pg_query::OnConflictExpr* unsafe_arena_release_on_conflict();

  private:
  const ::pg_query::OnConflictExpr& _internal_on_conflict() const;
  ::pg_query::OnConflictExpr* _internal_mutable_on_conflict();

  public:
  // .pg_query.Node having_qual = 29 [json_name = "havingQual"];
  bool has_having_qual() const;
  void clear_having_qual() ;
  const ::pg_query::Node& having_qual() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_having_qual();
  ::pg_query::Node* mutable_having_qual();
  void set_allocated_having_qual(::pg_query::Node* value);
  void unsafe_arena_set_allocated_having_qual(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_having_qual();

  private:
  const ::pg_query::Node& _internal_having_qual() const;
  ::pg_query::Node* _internal_mutable_having_qual();

  public:
  // .pg_query.Node limit_offset = 33 [json_name = "limitOffset"];
  bool has_limit_offset() const;
  void clear_limit_offset() ;
  const ::pg_query::Node& limit_offset() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_limit_offset();
  ::pg_query::Node* mutable_limit_offset();
  void set_allocated_limit_offset(::pg_query::Node* value);
  void unsafe_arena_set_allocated_limit_offset(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_limit_offset();

  private:
  const ::pg_query::Node& _internal_limit_offset() const;
  ::pg_query::Node* _internal_mutable_limit_offset();

  public:
  // .pg_query.Node limit_count = 34 [json_name = "limitCount"];
  bool has_limit_count() const;
  void clear_limit_count() ;
  const ::pg_query::Node& limit_count() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_limit_count();
  ::pg_query::Node* mutable_limit_count();
  void set_allocated_limit_count(::pg_query::Node* value);
  void unsafe_arena_set_allocated_limit_count(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_limit_count();

  private:
  const ::pg_query::Node& _internal_limit_count() const;
  ::pg_query::Node* _internal_mutable_limit_count();

  public:
  // .pg_query.Node set_operations = 37 [json_name = "setOperations"];
  bool has_set_operations() const;
  void clear_set_operations() ;
  const ::pg_query::Node& set_operations() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_set_operations();
  ::pg_query::Node* mutable_set_operations();
  void set_allocated_set_operations(::pg_query::Node* value);
  void unsafe_arena_set_allocated_set_operations(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_set_operations();

  private:
  const ::pg_query::Node& _internal_set_operations() const;
  ::pg_query::Node* _internal_mutable_set_operations();

  public:
  // .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() ;
  ::int32_t result_relation() const;
  void set_result_relation(::int32_t value);

  private:
  ::int32_t _internal_result_relation() const;
  void _internal_set_result_relation(::int32_t 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:
  // bool is_return = 15 [json_name = "isReturn"];
  void clear_is_return() ;
  bool is_return() const;
  void set_is_return(bool value);

  private:
  bool _internal_is_return() const;
  void _internal_set_is_return(bool value);

  public:
  // bool merge_use_outer_join = 21 [json_name = "mergeUseOuterJoin"];
  void clear_merge_use_outer_join() ;
  bool merge_use_outer_join() const;
  void set_merge_use_outer_join(bool value);

  private:
  bool _internal_merge_use_outer_join() const;
  void _internal_set_merge_use_outer_join(bool value);

  public:
  // .pg_query.OverridingKind override = 23 [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:
  // bool group_distinct = 27 [json_name = "groupDistinct"];
  void clear_group_distinct() ;
  bool group_distinct() const;
  void set_group_distinct(bool value);

  private:
  bool _internal_group_distinct() const;
  void _internal_set_group_distinct(bool value);

  public:
  // .pg_query.LimitOption limit_option = 35 [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 = 40 [json_name = "stmt_location"];
  void clear_stmt_location() ;
  ::int32_t stmt_location() const;
  void set_stmt_location(::int32_t value);

  private:
  ::int32_t _internal_stmt_location() const;
  void _internal_set_stmt_location(::int32_t value);

  public:
  // int32 stmt_len = 41 [json_name = "stmt_len"];
  void clear_stmt_len() ;
  ::int32_t stmt_len() const;
  void set_stmt_len(::int32_t value);

  private:
  ::int32_t _internal_stmt_len() const;
  void _internal_set_stmt_len(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.Query)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      5, 41, 21,
      0, 7>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > cte_list_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > rtable_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > rteperminfos_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > merge_action_list_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > target_list_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > returning_list_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > group_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > grouping_sets_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > window_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > distinct_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > sort_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > row_marks_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > constraint_deps_;
    ::google::protobuf::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_;
    ::int32_t 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_;
    bool is_return_;
    bool merge_use_outer_join_;
    int override_;
    bool group_distinct_;
    int limit_option_;
    ::int32_t stmt_location_;
    ::int32_t stmt_len_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RangeFunction final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeFunction) */ {
 public:
  inline RangeFunction() : RangeFunction(nullptr) {}
  ~RangeFunction() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RangeFunction(::google::protobuf::internal::ConstantInitialized);

  inline RangeFunction(const RangeFunction& from)
      : RangeFunction(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RangeFunction& default_instance() {
    return *internal_default_instance();
  }
  static inline const RangeFunction* internal_default_instance() {
    return reinterpret_cast<const RangeFunction*>(
               &_RangeFunction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    85;

  friend void swap(RangeFunction& a, RangeFunction& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeFunction* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeFunction* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RangeFunction* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RangeFunction>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RangeFunction& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RangeFunction& from) {
    RangeFunction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RangeFunction* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RangeFunction";
  }
  protected:
  explicit RangeFunction(::google::protobuf::Arena* arena);
  RangeFunction(::google::protobuf::Arena* arena, const RangeFunction& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_functions();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_functions() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_functions();
  public:
  const ::pg_query::Node& functions(int index) const;
  ::pg_query::Node* add_functions();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_coldeflist();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_coldeflist() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_coldeflist();
  public:
  const ::pg_query::Node& coldeflist(int index) const;
  ::pg_query::Node* add_coldeflist();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      coldeflist() const;
  // .pg_query.Alias alias = 5 [json_name = "alias"];
  bool has_alias() const;
  void clear_alias() ;
  const ::pg_query::Alias& alias() const;
  PROTOBUF_NODISCARD ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* value);
  void unsafe_arena_set_allocated_alias(::pg_query::Alias* value);
  ::pg_query::Alias* unsafe_arena_release_alias();

  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > functions_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > coldeflist_;
    ::pg_query::Alias* alias_;
    bool lateral_;
    bool ordinality_;
    bool is_rowsfrom_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RangeSubselect final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeSubselect) */ {
 public:
  inline RangeSubselect() : RangeSubselect(nullptr) {}
  ~RangeSubselect() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RangeSubselect(::google::protobuf::internal::ConstantInitialized);

  inline RangeSubselect(const RangeSubselect& from)
      : RangeSubselect(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RangeSubselect& default_instance() {
    return *internal_default_instance();
  }
  static inline const RangeSubselect* internal_default_instance() {
    return reinterpret_cast<const RangeSubselect*>(
               &_RangeSubselect_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    84;

  friend void swap(RangeSubselect& a, RangeSubselect& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeSubselect* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeSubselect* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RangeSubselect* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RangeSubselect>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RangeSubselect& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RangeSubselect& from) {
    RangeSubselect::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RangeSubselect* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RangeSubselect";
  }
  protected:
  explicit RangeSubselect(::google::protobuf::Arena* arena);
  RangeSubselect(::google::protobuf::Arena* arena, const RangeSubselect& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSubqueryFieldNumber = 2,
    kAliasFieldNumber = 3,
    kLateralFieldNumber = 1,
  };
  // .pg_query.Node subquery = 2 [json_name = "subquery"];
  bool has_subquery() const;
  void clear_subquery() ;
  const ::pg_query::Node& subquery() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_subquery();
  ::pg_query::Node* mutable_subquery();
  void set_allocated_subquery(::pg_query::Node* value);
  void unsafe_arena_set_allocated_subquery(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_subquery();

  private:
  const ::pg_query::Node& _internal_subquery() const;
  ::pg_query::Node* _internal_mutable_subquery();

  public:
  // .pg_query.Alias alias = 3 [json_name = "alias"];
  bool has_alias() const;
  void clear_alias() ;
  const ::pg_query::Alias& alias() const;
  PROTOBUF_NODISCARD ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* value);
  void unsafe_arena_set_allocated_alias(::pg_query::Alias* value);
  ::pg_query::Alias* unsafe_arena_release_alias();

  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* subquery_;
    ::pg_query::Alias* alias_;
    bool lateral_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RangeTableFunc final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTableFunc) */ {
 public:
  inline RangeTableFunc() : RangeTableFunc(nullptr) {}
  ~RangeTableFunc() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RangeTableFunc(::google::protobuf::internal::ConstantInitialized);

  inline RangeTableFunc(const RangeTableFunc& from)
      : RangeTableFunc(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RangeTableFunc& default_instance() {
    return *internal_default_instance();
  }
  static inline const RangeTableFunc* internal_default_instance() {
    return reinterpret_cast<const RangeTableFunc*>(
               &_RangeTableFunc_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    86;

  friend void swap(RangeTableFunc& a, RangeTableFunc& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeTableFunc* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeTableFunc* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RangeTableFunc* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RangeTableFunc>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RangeTableFunc& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RangeTableFunc& from) {
    RangeTableFunc::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RangeTableFunc* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RangeTableFunc";
  }
  protected:
  explicit RangeTableFunc(::google::protobuf::Arena* arena);
  RangeTableFunc(::google::protobuf::Arena* arena, const RangeTableFunc& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_namespaces();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_namespaces() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_namespaces();
  public:
  const ::pg_query::Node& namespaces(int index) const;
  ::pg_query::Node* add_namespaces();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_columns();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_columns() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_columns();
  public:
  const ::pg_query::Node& columns(int index) const;
  ::pg_query::Node* add_columns();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      columns() const;
  // .pg_query.Node docexpr = 2 [json_name = "docexpr"];
  bool has_docexpr() const;
  void clear_docexpr() ;
  const ::pg_query::Node& docexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_docexpr();
  ::pg_query::Node* mutable_docexpr();
  void set_allocated_docexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_docexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_docexpr();

  private:
  const ::pg_query::Node& _internal_docexpr() const;
  ::pg_query::Node* _internal_mutable_docexpr();

  public:
  // .pg_query.Node rowexpr = 3 [json_name = "rowexpr"];
  bool has_rowexpr() const;
  void clear_rowexpr() ;
  const ::pg_query::Node& rowexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_rowexpr();
  ::pg_query::Node* mutable_rowexpr();
  void set_allocated_rowexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_rowexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_rowexpr();

  private:
  const ::pg_query::Node& _internal_rowexpr() const;
  ::pg_query::Node* _internal_mutable_rowexpr();

  public:
  // .pg_query.Alias alias = 6 [json_name = "alias"];
  bool has_alias() const;
  void clear_alias() ;
  const ::pg_query::Alias& alias() const;
  PROTOBUF_NODISCARD ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* value);
  void unsafe_arena_set_allocated_alias(::pg_query::Alias* value);
  ::pg_query::Alias* unsafe_arena_release_alias();

  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();

  public:
  // 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.RangeTableFunc)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 5,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > namespaces_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > columns_;
    ::pg_query::Node* docexpr_;
    ::pg_query::Node* rowexpr_;
    ::pg_query::Alias* alias_;
    bool lateral_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RangeTableFuncCol final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTableFuncCol) */ {
 public:
  inline RangeTableFuncCol() : RangeTableFuncCol(nullptr) {}
  ~RangeTableFuncCol() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RangeTableFuncCol(::google::protobuf::internal::ConstantInitialized);

  inline RangeTableFuncCol(const RangeTableFuncCol& from)
      : RangeTableFuncCol(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RangeTableFuncCol& default_instance() {
    return *internal_default_instance();
  }
  static inline const RangeTableFuncCol* internal_default_instance() {
    return reinterpret_cast<const RangeTableFuncCol*>(
               &_RangeTableFuncCol_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    87;

  friend void swap(RangeTableFuncCol& a, RangeTableFuncCol& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeTableFuncCol* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeTableFuncCol* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RangeTableFuncCol* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RangeTableFuncCol>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RangeTableFuncCol& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RangeTableFuncCol& from) {
    RangeTableFuncCol::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RangeTableFuncCol* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RangeTableFuncCol";
  }
  protected:
  explicit RangeTableFuncCol(::google::protobuf::Arena* arena);
  RangeTableFuncCol(::google::protobuf::Arena* arena, const RangeTableFuncCol& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_colname(Arg_&& arg, Args_... args);
  std::string* mutable_colname();
  PROTOBUF_NODISCARD std::string* release_colname();
  void set_allocated_colname(std::string* value);

  private:
  const std::string& _internal_colname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_type_name() ;
  const ::pg_query::TypeName& type_name() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_type_name(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();

  public:
  // .pg_query.Node colexpr = 5 [json_name = "colexpr"];
  bool has_colexpr() const;
  void clear_colexpr() ;
  const ::pg_query::Node& colexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_colexpr();
  ::pg_query::Node* mutable_colexpr();
  void set_allocated_colexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_colexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_colexpr();

  private:
  const ::pg_query::Node& _internal_colexpr() const;
  ::pg_query::Node* _internal_mutable_colexpr();

  public:
  // .pg_query.Node coldefexpr = 6 [json_name = "coldefexpr"];
  bool has_coldefexpr() const;
  void clear_coldefexpr() ;
  const ::pg_query::Node& coldefexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_coldefexpr();
  ::pg_query::Node* mutable_coldefexpr();
  void set_allocated_coldefexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_coldefexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_coldefexpr();

  private:
  const ::pg_query::Node& _internal_coldefexpr() const;
  ::pg_query::Node* _internal_mutable_coldefexpr();

  public:
  // 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.RangeTableFuncCol)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 3,
      42, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr colname_;
    ::pg_query::TypeName* type_name_;
    ::pg_query::Node* colexpr_;
    ::pg_query::Node* coldefexpr_;
    bool for_ordinality_;
    bool is_not_null_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RangeTableSample final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTableSample) */ {
 public:
  inline RangeTableSample() : RangeTableSample(nullptr) {}
  ~RangeTableSample() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RangeTableSample(::google::protobuf::internal::ConstantInitialized);

  inline RangeTableSample(const RangeTableSample& from)
      : RangeTableSample(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RangeTableSample& default_instance() {
    return *internal_default_instance();
  }
  static inline const RangeTableSample* internal_default_instance() {
    return reinterpret_cast<const RangeTableSample*>(
               &_RangeTableSample_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    88;

  friend void swap(RangeTableSample& a, RangeTableSample& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeTableSample* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeTableSample* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RangeTableSample* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RangeTableSample>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RangeTableSample& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RangeTableSample& from) {
    RangeTableSample::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RangeTableSample* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RangeTableSample";
  }
  protected:
  explicit RangeTableSample(::google::protobuf::Arena* arena);
  RangeTableSample(::google::protobuf::Arena* arena, const RangeTableSample& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_method();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_method() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_method();
  public:
  const ::pg_query::Node& method(int index) const;
  ::pg_query::Node* add_method();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node relation = 1 [json_name = "relation"];
  bool has_relation() const;
  void clear_relation() ;
  const ::pg_query::Node& relation() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_relation();
  ::pg_query::Node* mutable_relation();
  void set_allocated_relation(::pg_query::Node* value);
  void unsafe_arena_set_allocated_relation(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_relation();

  private:
  const ::pg_query::Node& _internal_relation() const;
  ::pg_query::Node* _internal_mutable_relation();

  public:
  // .pg_query.Node repeatable = 4 [json_name = "repeatable"];
  bool has_repeatable() const;
  void clear_repeatable() ;
  const ::pg_query::Node& repeatable() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_repeatable();
  ::pg_query::Node* mutable_repeatable();
  void set_allocated_repeatable(::pg_query::Node* value);
  void unsafe_arena_set_allocated_repeatable(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_repeatable();

  private:
  const ::pg_query::Node& _internal_repeatable() const;
  ::pg_query::Node* _internal_mutable_repeatable();

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.RangeTableSample)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 4,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > method_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* relation_;
    ::pg_query::Node* repeatable_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RangeTblEntry final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTblEntry) */ {
 public:
  inline RangeTblEntry() : RangeTblEntry(nullptr) {}
  ~RangeTblEntry() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RangeTblEntry(::google::protobuf::internal::ConstantInitialized);

  inline RangeTblEntry(const RangeTblEntry& from)
      : RangeTblEntry(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RangeTblEntry& default_instance() {
    return *internal_default_instance();
  }
  static inline const RangeTblEntry* internal_default_instance() {
    return reinterpret_cast<const RangeTblEntry*>(
               &_RangeTblEntry_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    100;

  friend void swap(RangeTblEntry& a, RangeTblEntry& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeTblEntry* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeTblEntry* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RangeTblEntry* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RangeTblEntry>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RangeTblEntry& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RangeTblEntry& from) {
    RangeTblEntry::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RangeTblEntry* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RangeTblEntry";
  }
  protected:
  explicit RangeTblEntry(::google::protobuf::Arena* arena);
  RangeTblEntry(::google::protobuf::Arena* arena, const RangeTblEntry& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kJoinaliasvarsFieldNumber = 11,
    kJoinleftcolsFieldNumber = 12,
    kJoinrightcolsFieldNumber = 13,
    kFunctionsFieldNumber = 15,
    kValuesListsFieldNumber = 18,
    kColtypesFieldNumber = 22,
    kColtypmodsFieldNumber = 23,
    kColcollationsFieldNumber = 24,
    kSecurityQualsFieldNumber = 32,
    kRelkindFieldNumber = 3,
    kCtenameFieldNumber = 19,
    kEnrnameFieldNumber = 25,
    kTablesampleFieldNumber = 5,
    kSubqueryFieldNumber = 7,
    kJoinUsingAliasFieldNumber = 14,
    kTablefuncFieldNumber = 17,
    kAliasFieldNumber = 27,
    kErefFieldNumber = 28,
    kRtekindFieldNumber = 1,
    kRelidFieldNumber = 2,
    kRellockmodeFieldNumber = 4,
    kPerminfoindexFieldNumber = 6,
    kJointypeFieldNumber = 9,
    kJoinmergedcolsFieldNumber = 10,
    kSecurityBarrierFieldNumber = 8,
    kFuncordinalityFieldNumber = 16,
    kSelfReferenceFieldNumber = 21,
    kLateralFieldNumber = 29,
    kCtelevelsupFieldNumber = 20,
    kEnrtuplesFieldNumber = 26,
    kInhFieldNumber = 30,
    kInFromClFieldNumber = 31,
  };
  // repeated .pg_query.Node joinaliasvars = 11 [json_name = "joinaliasvars"];
  int joinaliasvars_size() const;
  private:
  int _internal_joinaliasvars_size() const;

  public:
  void clear_joinaliasvars() ;
  ::pg_query::Node* mutable_joinaliasvars(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_joinaliasvars();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_joinaliasvars() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_joinaliasvars();
  public:
  const ::pg_query::Node& joinaliasvars(int index) const;
  ::pg_query::Node* add_joinaliasvars();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      joinaliasvars() const;
  // repeated .pg_query.Node joinleftcols = 12 [json_name = "joinleftcols"];
  int joinleftcols_size() const;
  private:
  int _internal_joinleftcols_size() const;

  public:
  void clear_joinleftcols() ;
  ::pg_query::Node* mutable_joinleftcols(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_joinleftcols();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_joinleftcols() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_joinleftcols();
  public:
  const ::pg_query::Node& joinleftcols(int index) const;
  ::pg_query::Node* add_joinleftcols();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      joinleftcols() const;
  // repeated .pg_query.Node joinrightcols = 13 [json_name = "joinrightcols"];
  int joinrightcols_size() const;
  private:
  int _internal_joinrightcols_size() const;

  public:
  void clear_joinrightcols() ;
  ::pg_query::Node* mutable_joinrightcols(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_joinrightcols();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_joinrightcols() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_joinrightcols();
  public:
  const ::pg_query::Node& joinrightcols(int index) const;
  ::pg_query::Node* add_joinrightcols();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      joinrightcols() const;
  // repeated .pg_query.Node functions = 15 [json_name = "functions"];
  int functions_size() const;
  private:
  int _internal_functions_size() const;

  public:
  void clear_functions() ;
  ::pg_query::Node* mutable_functions(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_functions();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_functions() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_functions();
  public:
  const ::pg_query::Node& functions(int index) const;
  ::pg_query::Node* add_functions();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      functions() const;
  // repeated .pg_query.Node values_lists = 18 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_values_lists();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_values_lists() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_values_lists();
  public:
  const ::pg_query::Node& values_lists(int index) const;
  ::pg_query::Node* add_values_lists();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      values_lists() const;
  // repeated .pg_query.Node coltypes = 22 [json_name = "coltypes"];
  int coltypes_size() const;
  private:
  int _internal_coltypes_size() const;

  public:
  void clear_coltypes() ;
  ::pg_query::Node* mutable_coltypes(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_coltypes();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_coltypes() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_coltypes();
  public:
  const ::pg_query::Node& coltypes(int index) const;
  ::pg_query::Node* add_coltypes();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      coltypes() const;
  // repeated .pg_query.Node coltypmods = 23 [json_name = "coltypmods"];
  int coltypmods_size() const;
  private:
  int _internal_coltypmods_size() const;

  public:
  void clear_coltypmods() ;
  ::pg_query::Node* mutable_coltypmods(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_coltypmods();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_coltypmods() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_coltypmods();
  public:
  const ::pg_query::Node& coltypmods(int index) const;
  ::pg_query::Node* add_coltypmods();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      coltypmods() const;
  // repeated .pg_query.Node colcollations = 24 [json_name = "colcollations"];
  int colcollations_size() const;
  private:
  int _internal_colcollations_size() const;

  public:
  void clear_colcollations() ;
  ::pg_query::Node* mutable_colcollations(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_colcollations();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_colcollations() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_colcollations();
  public:
  const ::pg_query::Node& colcollations(int index) const;
  ::pg_query::Node* add_colcollations();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_security_quals();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_security_quals() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_security_quals();
  public:
  const ::pg_query::Node& security_quals(int index) const;
  ::pg_query::Node* add_security_quals();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      security_quals() const;
  // string relkind = 3 [json_name = "relkind"];
  void clear_relkind() ;
  const std::string& relkind() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_relkind(Arg_&& arg, Args_... args);
  std::string* mutable_relkind();
  PROTOBUF_NODISCARD std::string* release_relkind();
  void set_allocated_relkind(std::string* value);

  private:
  const std::string& _internal_relkind() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_relkind(
      const std::string& value);
  std::string* _internal_mutable_relkind();

  public:
  // string ctename = 19 [json_name = "ctename"];
  void clear_ctename() ;
  const std::string& ctename() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_ctename(Arg_&& arg, Args_... args);
  std::string* mutable_ctename();
  PROTOBUF_NODISCARD std::string* release_ctename();
  void set_allocated_ctename(std::string* value);

  private:
  const std::string& _internal_ctename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ctename(
      const std::string& value);
  std::string* _internal_mutable_ctename();

  public:
  // string enrname = 25 [json_name = "enrname"];
  void clear_enrname() ;
  const std::string& enrname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_enrname(Arg_&& arg, Args_... args);
  std::string* mutable_enrname();
  PROTOBUF_NODISCARD std::string* release_enrname();
  void set_allocated_enrname(std::string* value);

  private:
  const std::string& _internal_enrname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_tablesample() ;
  const ::pg_query::TableSampleClause& tablesample() const;
  PROTOBUF_NODISCARD ::pg_query::TableSampleClause* release_tablesample();
  ::pg_query::TableSampleClause* mutable_tablesample();
  void set_allocated_tablesample(::pg_query::TableSampleClause* value);
  void unsafe_arena_set_allocated_tablesample(::pg_query::TableSampleClause* value);
  ::pg_query::TableSampleClause* unsafe_arena_release_tablesample();

  private:
  const ::pg_query::TableSampleClause& _internal_tablesample() const;
  ::pg_query::TableSampleClause* _internal_mutable_tablesample();

  public:
  // .pg_query.Query subquery = 7 [json_name = "subquery"];
  bool has_subquery() const;
  void clear_subquery() ;
  const ::pg_query::Query& subquery() const;
  PROTOBUF_NODISCARD ::pg_query::Query* release_subquery();
  ::pg_query::Query* mutable_subquery();
  void set_allocated_subquery(::pg_query::Query* value);
  void unsafe_arena_set_allocated_subquery(::pg_query::Query* value);
  ::pg_query::Query* unsafe_arena_release_subquery();

  private:
  const ::pg_query::Query& _internal_subquery() const;
  ::pg_query::Query* _internal_mutable_subquery();

  public:
  // .pg_query.Alias join_using_alias = 14 [json_name = "join_using_alias"];
  bool has_join_using_alias() const;
  void clear_join_using_alias() ;
  const ::pg_query::Alias& join_using_alias() const;
  PROTOBUF_NODISCARD ::pg_query::Alias* release_join_using_alias();
  ::pg_query::Alias* mutable_join_using_alias();
  void set_allocated_join_using_alias(::pg_query::Alias* value);
  void unsafe_arena_set_allocated_join_using_alias(::pg_query::Alias* value);
  ::pg_query::Alias* unsafe_arena_release_join_using_alias();

  private:
  const ::pg_query::Alias& _internal_join_using_alias() const;
  ::pg_query::Alias* _internal_mutable_join_using_alias();

  public:
  // .pg_query.TableFunc tablefunc = 17 [json_name = "tablefunc"];
  bool has_tablefunc() const;
  void clear_tablefunc() ;
  const ::pg_query::TableFunc& tablefunc() const;
  PROTOBUF_NODISCARD ::pg_query::TableFunc* release_tablefunc();
  ::pg_query::TableFunc* mutable_tablefunc();
  void set_allocated_tablefunc(::pg_query::TableFunc* value);
  void unsafe_arena_set_allocated_tablefunc(::pg_query::TableFunc* value);
  ::pg_query::TableFunc* unsafe_arena_release_tablefunc();

  private:
  const ::pg_query::TableFunc& _internal_tablefunc() const;
  ::pg_query::TableFunc* _internal_mutable_tablefunc();

  public:
  // .pg_query.Alias alias = 27 [json_name = "alias"];
  bool has_alias() const;
  void clear_alias() ;
  const ::pg_query::Alias& alias() const;
  PROTOBUF_NODISCARD ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* value);
  void unsafe_arena_set_allocated_alias(::pg_query::Alias* value);
  ::pg_query::Alias* unsafe_arena_release_alias();

  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();

  public:
  // .pg_query.Alias eref = 28 [json_name = "eref"];
  bool has_eref() const;
  void clear_eref() ;
  const ::pg_query::Alias& eref() const;
  PROTOBUF_NODISCARD ::pg_query::Alias* release_eref();
  ::pg_query::Alias* mutable_eref();
  void set_allocated_eref(::pg_query::Alias* value);
  void unsafe_arena_set_allocated_eref(::pg_query::Alias* value);
  ::pg_query::Alias* unsafe_arena_release_eref();

  private:
  const ::pg_query::Alias& _internal_eref() const;
  ::pg_query::Alias* _internal_mutable_eref();

  public:
  // .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() ;
  ::uint32_t relid() const;
  void set_relid(::uint32_t value);

  private:
  ::uint32_t _internal_relid() const;
  void _internal_set_relid(::uint32_t value);

  public:
  // int32 rellockmode = 4 [json_name = "rellockmode"];
  void clear_rellockmode() ;
  ::int32_t rellockmode() const;
  void set_rellockmode(::int32_t value);

  private:
  ::int32_t _internal_rellockmode() const;
  void _internal_set_rellockmode(::int32_t value);

  public:
  // uint32 perminfoindex = 6 [json_name = "perminfoindex"];
  void clear_perminfoindex() ;
  ::uint32_t perminfoindex() const;
  void set_perminfoindex(::uint32_t value);

  private:
  ::uint32_t _internal_perminfoindex() const;
  void _internal_set_perminfoindex(::uint32_t value);

  public:
  // .pg_query.JoinType jointype = 9 [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 = 10 [json_name = "joinmergedcols"];
  void clear_joinmergedcols() ;
  ::int32_t joinmergedcols() const;
  void set_joinmergedcols(::int32_t value);

  private:
  ::int32_t _internal_joinmergedcols() const;
  void _internal_set_joinmergedcols(::int32_t value);

  public:
  // bool security_barrier = 8 [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 = 16 [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 = 21 [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 = 29 [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:
  // uint32 ctelevelsup = 20 [json_name = "ctelevelsup"];
  void clear_ctelevelsup() ;
  ::uint32_t ctelevelsup() const;
  void set_ctelevelsup(::uint32_t value);

  private:
  ::uint32_t _internal_ctelevelsup() const;
  void _internal_set_ctelevelsup(::uint32_t value);

  public:
  // double enrtuples = 26 [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:
  // bool inh = 30 [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 = 31 [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:
  // @@protoc_insertion_point(class_scope:pg_query.RangeTblEntry)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      5, 32, 15,
      84, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > joinaliasvars_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > joinleftcols_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > joinrightcols_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > functions_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > values_lists_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > coltypes_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > coltypmods_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > colcollations_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > security_quals_;
    ::google::protobuf::internal::ArenaStringPtr relkind_;
    ::google::protobuf::internal::ArenaStringPtr ctename_;
    ::google::protobuf::internal::ArenaStringPtr enrname_;
    ::pg_query::TableSampleClause* tablesample_;
    ::pg_query::Query* subquery_;
    ::pg_query::Alias* join_using_alias_;
    ::pg_query::TableFunc* tablefunc_;
    ::pg_query::Alias* alias_;
    ::pg_query::Alias* eref_;
    int rtekind_;
    ::uint32_t relid_;
    ::int32_t rellockmode_;
    ::uint32_t perminfoindex_;
    int jointype_;
    ::int32_t joinmergedcols_;
    bool security_barrier_;
    bool funcordinality_;
    bool self_reference_;
    bool lateral_;
    ::uint32_t ctelevelsup_;
    double enrtuples_;
    bool inh_;
    bool in_from_cl_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RangeTblFunction final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTblFunction) */ {
 public:
  inline RangeTblFunction() : RangeTblFunction(nullptr) {}
  ~RangeTblFunction() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RangeTblFunction(::google::protobuf::internal::ConstantInitialized);

  inline RangeTblFunction(const RangeTblFunction& from)
      : RangeTblFunction(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RangeTblFunction& default_instance() {
    return *internal_default_instance();
  }
  static inline const RangeTblFunction* internal_default_instance() {
    return reinterpret_cast<const RangeTblFunction*>(
               &_RangeTblFunction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    102;

  friend void swap(RangeTblFunction& a, RangeTblFunction& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeTblFunction* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeTblFunction* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RangeTblFunction* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RangeTblFunction>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RangeTblFunction& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RangeTblFunction& from) {
    RangeTblFunction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RangeTblFunction* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RangeTblFunction";
  }
  protected:
  explicit RangeTblFunction(::google::protobuf::Arena* arena);
  RangeTblFunction(::google::protobuf::Arena* arena, const RangeTblFunction& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFunccolnamesFieldNumber = 3,
    kFunccoltypesFieldNumber = 4,
    kFunccoltypmodsFieldNumber = 5,
    kFunccolcollationsFieldNumber = 6,
    kFuncparamsFieldNumber = 7,
    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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_funccolnames();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_funccolnames() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_funccolnames();
  public:
  const ::pg_query::Node& funccolnames(int index) const;
  ::pg_query::Node* add_funccolnames();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_funccoltypes();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_funccoltypes() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_funccoltypes();
  public:
  const ::pg_query::Node& funccoltypes(int index) const;
  ::pg_query::Node* add_funccoltypes();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_funccoltypmods();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_funccoltypmods() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_funccoltypmods();
  public:
  const ::pg_query::Node& funccoltypmods(int index) const;
  ::pg_query::Node* add_funccoltypmods();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_funccolcollations();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_funccolcollations() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_funccolcollations();
  public:
  const ::pg_query::Node& funccolcollations(int index) const;
  ::pg_query::Node* add_funccolcollations();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      funccolcollations() const;
  // repeated uint64 funcparams = 7 [json_name = "funcparams"];
  int funcparams_size() const;
  private:
  int _internal_funcparams_size() const;

  public:
  void clear_funcparams() ;
  ::uint64_t funcparams(int index) const;
  void set_funcparams(int index, ::uint64_t value);
  void add_funcparams(::uint64_t value);
  const ::google::protobuf::RepeatedField<::uint64_t>& funcparams() const;
  ::google::protobuf::RepeatedField<::uint64_t>* mutable_funcparams();

  private:
  const ::google::protobuf::RepeatedField<::uint64_t>& _internal_funcparams() const;
  ::google::protobuf::RepeatedField<::uint64_t>* _internal_mutable_funcparams();

  public:
  // .pg_query.Node funcexpr = 1 [json_name = "funcexpr"];
  bool has_funcexpr() const;
  void clear_funcexpr() ;
  const ::pg_query::Node& funcexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_funcexpr();
  ::pg_query::Node* mutable_funcexpr();
  void set_allocated_funcexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_funcexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_funcexpr();

  private:
  const ::pg_query::Node& _internal_funcexpr() const;
  ::pg_query::Node* _internal_mutable_funcexpr();

  public:
  // int32 funccolcount = 2 [json_name = "funccolcount"];
  void clear_funccolcount() ;
  ::int32_t funccolcount() const;
  void set_funccolcount(::int32_t value);

  private:
  ::int32_t _internal_funccolcount() const;
  void _internal_set_funccolcount(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.RangeTblFunction)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 5,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > funccolnames_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > funccoltypes_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > funccoltypmods_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > funccolcollations_;
    ::google::protobuf::RepeatedField<::uint64_t> funcparams_;
    mutable ::google::protobuf::internal::CachedSize _funcparams_cached_byte_size_;
    ::pg_query::Node* funcexpr_;
    ::int32_t funccolcount_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RangeVar final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeVar) */ {
 public:
  inline RangeVar() : RangeVar(nullptr) {}
  ~RangeVar() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RangeVar(::google::protobuf::internal::ConstantInitialized);

  inline RangeVar(const RangeVar& from)
      : RangeVar(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RangeVar& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeVar* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RangeVar* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RangeVar>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RangeVar& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RangeVar& from) {
    RangeVar::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RangeVar* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RangeVar";
  }
  protected:
  explicit RangeVar(::google::protobuf::Arena* arena);
  RangeVar(::google::protobuf::Arena* arena, const RangeVar& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_catalogname(Arg_&& arg, Args_... args);
  std::string* mutable_catalogname();
  PROTOBUF_NODISCARD std::string* release_catalogname();
  void set_allocated_catalogname(std::string* value);

  private:
  const std::string& _internal_catalogname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_schemaname(Arg_&& arg, Args_... args);
  std::string* mutable_schemaname();
  PROTOBUF_NODISCARD std::string* release_schemaname();
  void set_allocated_schemaname(std::string* value);

  private:
  const std::string& _internal_schemaname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_relname(Arg_&& arg, Args_... args);
  std::string* mutable_relname();
  PROTOBUF_NODISCARD std::string* release_relname();
  void set_allocated_relname(std::string* value);

  private:
  const std::string& _internal_relname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_relpersistence(Arg_&& arg, Args_... args);
  std::string* mutable_relpersistence();
  PROTOBUF_NODISCARD std::string* release_relpersistence();
  void set_allocated_relpersistence(std::string* value);

  private:
  const std::string& _internal_relpersistence() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_alias() ;
  const ::pg_query::Alias& alias() const;
  PROTOBUF_NODISCARD ::pg_query::Alias* release_alias();
  ::pg_query::Alias* mutable_alias();
  void set_allocated_alias(::pg_query::Alias* value);
  void unsafe_arena_set_allocated_alias(::pg_query::Alias* value);
  ::pg_query::Alias* unsafe_arena_release_alias();

  private:
  const ::pg_query::Alias& _internal_alias() const;
  ::pg_query::Alias* _internal_mutable_alias();

  public:
  // 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.RangeVar)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 1,
      68, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr catalogname_;
    ::google::protobuf::internal::ArenaStringPtr schemaname_;
    ::google::protobuf::internal::ArenaStringPtr relname_;
    ::google::protobuf::internal::ArenaStringPtr relpersistence_;
    ::pg_query::Alias* alias_;
    bool inh_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RawStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RawStmt) */ {
 public:
  inline RawStmt() : RawStmt(nullptr) {}
  ~RawStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RawStmt(::google::protobuf::internal::ConstantInitialized);

  inline RawStmt(const RawStmt& from)
      : RawStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RawStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const RawStmt* internal_default_instance() {
    return reinterpret_cast<const RawStmt*>(
               &_RawStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    126;

  friend void swap(RawStmt& a, RawStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(RawStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RawStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RawStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RawStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RawStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RawStmt& from) {
    RawStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RawStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RawStmt";
  }
  protected:
  explicit RawStmt(::google::protobuf::Arena* arena);
  RawStmt(::google::protobuf::Arena* arena, const RawStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kStmtFieldNumber = 1,
    kStmtLocationFieldNumber = 2,
    kStmtLenFieldNumber = 3,
  };
  // .pg_query.Node stmt = 1 [json_name = "stmt"];
  bool has_stmt() const;
  void clear_stmt() ;
  const ::pg_query::Node& stmt() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_stmt();
  ::pg_query::Node* mutable_stmt();
  void set_allocated_stmt(::pg_query::Node* value);
  void unsafe_arena_set_allocated_stmt(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_stmt();

  private:
  const ::pg_query::Node& _internal_stmt() const;
  ::pg_query::Node* _internal_mutable_stmt();

  public:
  // int32 stmt_location = 2 [json_name = "stmt_location"];
  void clear_stmt_location() ;
  ::int32_t stmt_location() const;
  void set_stmt_location(::int32_t value);

  private:
  ::int32_t _internal_stmt_location() const;
  void _internal_set_stmt_location(::int32_t value);

  public:
  // int32 stmt_len = 3 [json_name = "stmt_len"];
  void clear_stmt_len() ;
  ::int32_t stmt_len() const;
  void set_stmt_len(::int32_t value);

  private:
  ::int32_t _internal_stmt_len() const;
  void _internal_set_stmt_len(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.RawStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* stmt_;
    ::int32_t stmt_location_;
    ::int32_t stmt_len_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ReassignOwnedStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ReassignOwnedStmt) */ {
 public:
  inline ReassignOwnedStmt() : ReassignOwnedStmt(nullptr) {}
  ~ReassignOwnedStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ReassignOwnedStmt(::google::protobuf::internal::ConstantInitialized);

  inline ReassignOwnedStmt(const ReassignOwnedStmt& from)
      : ReassignOwnedStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ReassignOwnedStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReassignOwnedStmt* internal_default_instance() {
    return reinterpret_cast<const ReassignOwnedStmt*>(
               &_ReassignOwnedStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    245;

  friend void swap(ReassignOwnedStmt& a, ReassignOwnedStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ReassignOwnedStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ReassignOwnedStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ReassignOwnedStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReassignOwnedStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ReassignOwnedStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ReassignOwnedStmt& from) {
    ReassignOwnedStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ReassignOwnedStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ReassignOwnedStmt";
  }
  protected:
  explicit ReassignOwnedStmt(::google::protobuf::Arena* arena);
  ReassignOwnedStmt(::google::protobuf::Arena* arena, const ReassignOwnedStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_roles();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_roles() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_roles();
  public:
  const ::pg_query::Node& roles(int index) const;
  ::pg_query::Node* add_roles();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      roles() const;
  // .pg_query.RoleSpec newrole = 2 [json_name = "newrole"];
  bool has_newrole() const;
  void clear_newrole() ;
  const ::pg_query::RoleSpec& newrole() const;
  PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_newrole();
  ::pg_query::RoleSpec* mutable_newrole();
  void set_allocated_newrole(::pg_query::RoleSpec* value);
  void unsafe_arena_set_allocated_newrole(::pg_query::RoleSpec* value);
  ::pg_query::RoleSpec* unsafe_arena_release_newrole();

  private:
  const ::pg_query::RoleSpec& _internal_newrole() const;
  ::pg_query::RoleSpec* _internal_mutable_newrole();

  public:
  // @@protoc_insertion_point(class_scope:pg_query.ReassignOwnedStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > roles_;
    ::pg_query::RoleSpec* newrole_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RefreshMatViewStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RefreshMatViewStmt) */ {
 public:
  inline RefreshMatViewStmt() : RefreshMatViewStmt(nullptr) {}
  ~RefreshMatViewStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RefreshMatViewStmt(::google::protobuf::internal::ConstantInitialized);

  inline RefreshMatViewStmt(const RefreshMatViewStmt& from)
      : RefreshMatViewStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RefreshMatViewStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const RefreshMatViewStmt* internal_default_instance() {
    return reinterpret_cast<const RefreshMatViewStmt*>(
               &_RefreshMatViewStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    232;

  friend void swap(RefreshMatViewStmt& a, RefreshMatViewStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(RefreshMatViewStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RefreshMatViewStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RefreshMatViewStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RefreshMatViewStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RefreshMatViewStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RefreshMatViewStmt& from) {
    RefreshMatViewStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RefreshMatViewStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RefreshMatViewStmt";
  }
  protected:
  explicit RefreshMatViewStmt(::google::protobuf::Arena* arena);
  RefreshMatViewStmt(::google::protobuf::Arena* arena, const RefreshMatViewStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRelationFieldNumber = 3,
    kConcurrentFieldNumber = 1,
    kSkipDataFieldNumber = 2,
  };
  // .pg_query.RangeVar relation = 3 [json_name = "relation"];
  bool has_relation() const;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::RangeVar* relation_;
    bool concurrent_;
    bool skip_data_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ReindexStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ReindexStmt) */ {
 public:
  inline ReindexStmt() : ReindexStmt(nullptr) {}
  ~ReindexStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ReindexStmt(::google::protobuf::internal::ConstantInitialized);

  inline ReindexStmt(const ReindexStmt& from)
      : ReindexStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ReindexStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReindexStmt* internal_default_instance() {
    return reinterpret_cast<const ReindexStmt*>(
               &_ReindexStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    237;

  friend void swap(ReindexStmt& a, ReindexStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ReindexStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ReindexStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ReindexStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReindexStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ReindexStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ReindexStmt& from) {
    ReindexStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ReindexStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ReindexStmt";
  }
  protected:
  explicit ReindexStmt(::google::protobuf::Arena* arena);
  ReindexStmt(::google::protobuf::Arena* arena, const ReindexStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kParamsFieldNumber = 4,
    kNameFieldNumber = 3,
    kRelationFieldNumber = 2,
    kKindFieldNumber = 1,
  };
  // repeated .pg_query.Node params = 4 [json_name = "params"];
  int params_size() const;
  private:
  int _internal_params_size() const;

  public:
  void clear_params() ;
  ::pg_query::Node* mutable_params(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_params();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_params() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_params();
  public:
  const ::pg_query::Node& params(int index) const;
  ::pg_query::Node* add_params();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      params() const;
  // string name = 3 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .pg_query.RangeVar relation = 2 [json_name = "relation"];
  bool has_relation() const;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .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:
  // @@protoc_insertion_point(class_scope:pg_query.ReindexStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      33, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > params_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::pg_query::RangeVar* relation_;
    int kind_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RelabelType final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RelabelType) */ {
 public:
  inline RelabelType() : RelabelType(nullptr) {}
  ~RelabelType() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RelabelType(::google::protobuf::internal::ConstantInitialized);

  inline RelabelType(const RelabelType& from)
      : RelabelType(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RelabelType& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RelabelType* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RelabelType* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RelabelType>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RelabelType& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RelabelType& from) {
    RelabelType::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RelabelType* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RelabelType";
  }
  protected:
  explicit RelabelType(::google::protobuf::Arena* arena);
  RelabelType(::google::protobuf::Arena* arena, const RelabelType& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node arg = 2 [json_name = "arg"];
  bool has_arg() const;
  void clear_arg() ;
  const ::pg_query::Node& arg() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* value);
  void unsafe_arena_set_allocated_arg(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_arg();

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // uint32 resulttype = 3 [json_name = "resulttype"];
  void clear_resulttype() ;
  ::uint32_t resulttype() const;
  void set_resulttype(::uint32_t value);

  private:
  ::uint32_t _internal_resulttype() const;
  void _internal_set_resulttype(::uint32_t value);

  public:
  // int32 resulttypmod = 4 [json_name = "resulttypmod"];
  void clear_resulttypmod() ;
  ::int32_t resulttypmod() const;
  void set_resulttypmod(::int32_t value);

  private:
  ::int32_t _internal_resulttypmod() const;
  void _internal_set_resulttypmod(::int32_t value);

  public:
  // uint32 resultcollid = 5 [json_name = "resultcollid"];
  void clear_resultcollid() ;
  ::uint32_t resultcollid() const;
  void set_resultcollid(::uint32_t value);

  private:
  ::uint32_t _internal_resultcollid() const;
  void _internal_set_resultcollid(::uint32_t 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.RelabelType)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* arg_;
    ::uint32_t resulttype_;
    ::int32_t resulttypmod_;
    ::uint32_t resultcollid_;
    int relabelformat_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RenameStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RenameStmt) */ {
 public:
  inline RenameStmt() : RenameStmt(nullptr) {}
  ~RenameStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RenameStmt(::google::protobuf::internal::ConstantInitialized);

  inline RenameStmt(const RenameStmt& from)
      : RenameStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RenameStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const RenameStmt* internal_default_instance() {
    return reinterpret_cast<const RenameStmt*>(
               &_RenameStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    204;

  friend void swap(RenameStmt& a, RenameStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(RenameStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RenameStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RenameStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RenameStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RenameStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RenameStmt& from) {
    RenameStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RenameStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RenameStmt";
  }
  protected:
  explicit RenameStmt(::google::protobuf::Arena* arena);
  RenameStmt(::google::protobuf::Arena* arena, const RenameStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_subname(Arg_&& arg, Args_... args);
  std::string* mutable_subname();
  PROTOBUF_NODISCARD std::string* release_subname();
  void set_allocated_subname(std::string* value);

  private:
  const std::string& _internal_subname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_newname(Arg_&& arg, Args_... args);
  std::string* mutable_newname();
  PROTOBUF_NODISCARD std::string* release_newname();
  void set_allocated_newname(std::string* value);

  private:
  const std::string& _internal_newname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node object = 4 [json_name = "object"];
  bool has_object() const;
  void clear_object() ;
  const ::pg_query::Node& object() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* value);
  void unsafe_arena_set_allocated_object(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_object();

  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 2,
      50, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr subname_;
    ::google::protobuf::internal::ArenaStringPtr newname_;
    ::pg_query::RangeVar* relation_;
    ::pg_query::Node* object_;
    int rename_type_;
    int relation_type_;
    int behavior_;
    bool missing_ok_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ResTarget final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ResTarget) */ {
 public:
  inline ResTarget() : ResTarget(nullptr) {}
  ~ResTarget() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ResTarget(::google::protobuf::internal::ConstantInitialized);

  inline ResTarget(const ResTarget& from)
      : ResTarget(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ResTarget& default_instance() {
    return *internal_default_instance();
  }
  static inline const ResTarget* internal_default_instance() {
    return reinterpret_cast<const ResTarget*>(
               &_ResTarget_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    80;

  friend void swap(ResTarget& a, ResTarget& b) {
    a.Swap(&b);
  }
  inline void Swap(ResTarget* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ResTarget* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ResTarget* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ResTarget>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ResTarget& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ResTarget& from) {
    ResTarget::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ResTarget* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ResTarget";
  }
  protected:
  explicit ResTarget(::google::protobuf::Arena* arena);
  ResTarget(::google::protobuf::Arena* arena, const ResTarget& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_indirection();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_indirection() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_indirection();
  public:
  const ::pg_query::Node& indirection(int index) const;
  ::pg_query::Node* add_indirection();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      indirection() const;
  // string name = 1 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .pg_query.Node val = 3 [json_name = "val"];
  bool has_val() const;
  void clear_val() ;
  const ::pg_query::Node& val() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_val();
  ::pg_query::Node* mutable_val();
  void set_allocated_val(::pg_query::Node* value);
  void unsafe_arena_set_allocated_val(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_val();

  private:
  const ::pg_query::Node& _internal_val() const;
  ::pg_query::Node* _internal_mutable_val();

  public:
  // int32 location = 4 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.ResTarget)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 2,
      31, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > indirection_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::pg_query::Node* val_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ReturnStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ReturnStmt) */ {
 public:
  inline ReturnStmt() : ReturnStmt(nullptr) {}
  ~ReturnStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ReturnStmt(::google::protobuf::internal::ConstantInitialized);

  inline ReturnStmt(const ReturnStmt& from)
      : ReturnStmt(nullptr, from) {}
  ReturnStmt(ReturnStmt&& from) noexcept
    : ReturnStmt() {
    *this = ::std::move(from);
  }

  inline ReturnStmt& operator=(const ReturnStmt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReturnStmt& operator=(ReturnStmt&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ReturnStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReturnStmt* internal_default_instance() {
    return reinterpret_cast<const ReturnStmt*>(
               &_ReturnStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    133;

  friend void swap(ReturnStmt& a, ReturnStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ReturnStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ReturnStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ReturnStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReturnStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ReturnStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ReturnStmt& from) {
    ReturnStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ReturnStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ReturnStmt";
  }
  protected:
  explicit ReturnStmt(::google::protobuf::Arena* arena);
  ReturnStmt(::google::protobuf::Arena* arena, const ReturnStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kReturnvalFieldNumber = 1,
  };
  // .pg_query.Node returnval = 1 [json_name = "returnval"];
  bool has_returnval() const;
  void clear_returnval() ;
  const ::pg_query::Node& returnval() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_returnval();
  ::pg_query::Node* mutable_returnval();
  void set_allocated_returnval(::pg_query::Node* value);
  void unsafe_arena_set_allocated_returnval(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_returnval();

  private:
  const ::pg_query::Node& _internal_returnval() const;
  ::pg_query::Node* _internal_mutable_returnval();

  public:
  // @@protoc_insertion_point(class_scope:pg_query.ReturnStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* returnval_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RowCompareExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RowCompareExpr) */ {
 public:
  inline RowCompareExpr() : RowCompareExpr(nullptr) {}
  ~RowCompareExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RowCompareExpr(::google::protobuf::internal::ConstantInitialized);

  inline RowCompareExpr(const RowCompareExpr& from)
      : RowCompareExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RowCompareExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RowCompareExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RowCompareExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RowCompareExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RowCompareExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RowCompareExpr& from) {
    RowCompareExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RowCompareExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RowCompareExpr";
  }
  protected:
  explicit RowCompareExpr(::google::protobuf::Arena* arena);
  RowCompareExpr(::google::protobuf::Arena* arena, const RowCompareExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_opnos();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_opnos() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_opnos();
  public:
  const ::pg_query::Node& opnos(int index) const;
  ::pg_query::Node* add_opnos();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_opfamilies();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_opfamilies() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_opfamilies();
  public:
  const ::pg_query::Node& opfamilies(int index) const;
  ::pg_query::Node* add_opfamilies();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_inputcollids();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_inputcollids() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_inputcollids();
  public:
  const ::pg_query::Node& inputcollids(int index) const;
  ::pg_query::Node* add_inputcollids();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_largs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_largs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_largs();
  public:
  const ::pg_query::Node& largs(int index) const;
  ::pg_query::Node* add_largs();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_rargs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_rargs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_rargs();
  public:
  const ::pg_query::Node& rargs(int index) const;
  ::pg_query::Node* add_rargs();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      rargs() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 6,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > opnos_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > opfamilies_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > inputcollids_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > largs_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > rargs_;
    ::pg_query::Node* xpr_;
    int rctype_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RowExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RowExpr) */ {
 public:
  inline RowExpr() : RowExpr(nullptr) {}
  ~RowExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RowExpr(::google::protobuf::internal::ConstantInitialized);

  inline RowExpr(const RowExpr& from)
      : RowExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RowExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RowExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RowExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RowExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RowExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RowExpr& from) {
    RowExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RowExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RowExpr";
  }
  protected:
  explicit RowExpr(::google::protobuf::Arena* arena);
  RowExpr(::google::protobuf::Arena* arena, const RowExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_colnames();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_colnames() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_colnames();
  public:
  const ::pg_query::Node& colnames(int index) const;
  ::pg_query::Node* add_colnames();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      colnames() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 row_typeid = 3 [json_name = "row_typeid"];
  void clear_row_typeid() ;
  ::uint32_t row_typeid() const;
  void set_row_typeid(::uint32_t value);

  private:
  ::uint32_t _internal_row_typeid() const;
  void _internal_set_row_typeid(::uint32_t 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.RowExpr)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > colnames_;
    ::pg_query::Node* xpr_;
    ::uint32_t row_typeid_;
    int row_format_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class RuleStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.RuleStmt) */ {
 public:
  inline RuleStmt() : RuleStmt(nullptr) {}
  ~RuleStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR RuleStmt(::google::protobuf::internal::ConstantInitialized);

  inline RuleStmt(const RuleStmt& from)
      : RuleStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RuleStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const RuleStmt* internal_default_instance() {
    return reinterpret_cast<const RuleStmt*>(
               &_RuleStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    210;

  friend void swap(RuleStmt& a, RuleStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(RuleStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RuleStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RuleStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RuleStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const RuleStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const RuleStmt& from) {
    RuleStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(RuleStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.RuleStmt";
  }
  protected:
  explicit RuleStmt(::google::protobuf::Arena* arena);
  RuleStmt(::google::protobuf::Arena* arena, const RuleStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_actions();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_actions() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_actions();
  public:
  const ::pg_query::Node& actions(int index) const;
  ::pg_query::Node* add_actions();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      actions() const;
  // string rulename = 2 [json_name = "rulename"];
  void clear_rulename() ;
  const std::string& rulename() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_rulename(Arg_&& arg, Args_... args);
  std::string* mutable_rulename();
  PROTOBUF_NODISCARD std::string* release_rulename();
  void set_allocated_rulename(std::string* value);

  private:
  const std::string& _internal_rulename() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node where_clause = 3 [json_name = "whereClause"];
  bool has_where_clause() const;
  void clear_where_clause() ;
  const ::pg_query::Node& where_clause() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* value);
  void unsafe_arena_set_allocated_where_clause(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 3,
      34, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > actions_;
    ::google::protobuf::internal::ArenaStringPtr rulename_;
    ::pg_query::RangeVar* relation_;
    ::pg_query::Node* where_clause_;
    int event_;
    bool instead_;
    bool replace_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class SQLValueFunction final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.SQLValueFunction) */ {
 public:
  inline SQLValueFunction() : SQLValueFunction(nullptr) {}
  ~SQLValueFunction() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SQLValueFunction(::google::protobuf::internal::ConstantInitialized);

  inline SQLValueFunction(const SQLValueFunction& from)
      : SQLValueFunction(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SQLValueFunction& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SQLValueFunction* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SQLValueFunction* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SQLValueFunction>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SQLValueFunction& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const SQLValueFunction& from) {
    SQLValueFunction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(SQLValueFunction* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.SQLValueFunction";
  }
  protected:
  explicit SQLValueFunction(::google::protobuf::Arena* arena);
  SQLValueFunction(::google::protobuf::Arena* arena, const SQLValueFunction& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .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() ;
  ::uint32_t type() const;
  void set_type(::uint32_t value);

  private:
  ::uint32_t _internal_type() const;
  void _internal_set_type(::uint32_t value);

  public:
  // int32 typmod = 4 [json_name = "typmod"];
  void clear_typmod() ;
  ::int32_t typmod() const;
  void set_typmod(::int32_t value);

  private:
  ::int32_t _internal_typmod() const;
  void _internal_set_typmod(::int32_t value);

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.SQLValueFunction)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    int op_;
    ::uint32_t type_;
    ::int32_t typmod_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ScalarArrayOpExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ScalarArrayOpExpr) */ {
 public:
  inline ScalarArrayOpExpr() : ScalarArrayOpExpr(nullptr) {}
  ~ScalarArrayOpExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ScalarArrayOpExpr(::google::protobuf::internal::ConstantInitialized);

  inline ScalarArrayOpExpr(const ScalarArrayOpExpr& from)
      : ScalarArrayOpExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ScalarArrayOpExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScalarArrayOpExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ScalarArrayOpExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ScalarArrayOpExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ScalarArrayOpExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ScalarArrayOpExpr& from) {
    ScalarArrayOpExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ScalarArrayOpExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ScalarArrayOpExpr";
  }
  protected:
  explicit ScalarArrayOpExpr(::google::protobuf::Arena* arena);
  ScalarArrayOpExpr(::google::protobuf::Arena* arena, const ScalarArrayOpExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kArgsFieldNumber = 5,
    kXprFieldNumber = 1,
    kOpnoFieldNumber = 2,
    kUseOrFieldNumber = 3,
    kInputcollidFieldNumber = 4,
    kLocationFieldNumber = 6,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 opno = 2 [json_name = "opno"];
  void clear_opno() ;
  ::uint32_t opno() const;
  void set_opno(::uint32_t value);

  private:
  ::uint32_t _internal_opno() const;
  void _internal_set_opno(::uint32_t value);

  public:
  // bool use_or = 3 [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 = 4 [json_name = "inputcollid"];
  void clear_inputcollid() ;
  ::uint32_t inputcollid() const;
  void set_inputcollid(::uint32_t value);

  private:
  ::uint32_t _internal_inputcollid() const;
  void _internal_set_inputcollid(::uint32_t value);

  public:
  // int32 location = 6 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.ScalarArrayOpExpr)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* xpr_;
    ::uint32_t opno_;
    bool use_or_;
    ::uint32_t inputcollid_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class SecLabelStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.SecLabelStmt) */ {
 public:
  inline SecLabelStmt() : SecLabelStmt(nullptr) {}
  ~SecLabelStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SecLabelStmt(::google::protobuf::internal::ConstantInitialized);

  inline SecLabelStmt(const SecLabelStmt& from)
      : SecLabelStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SecLabelStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const SecLabelStmt* internal_default_instance() {
    return reinterpret_cast<const SecLabelStmt*>(
               &_SecLabelStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    189;

  friend void swap(SecLabelStmt& a, SecLabelStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(SecLabelStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SecLabelStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SecLabelStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SecLabelStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SecLabelStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const SecLabelStmt& from) {
    SecLabelStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(SecLabelStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.SecLabelStmt";
  }
  protected:
  explicit SecLabelStmt(::google::protobuf::Arena* arena);
  SecLabelStmt(::google::protobuf::Arena* arena, const SecLabelStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_provider(Arg_&& arg, Args_... args);
  std::string* mutable_provider();
  PROTOBUF_NODISCARD std::string* release_provider();
  void set_allocated_provider(std::string* value);

  private:
  const std::string& _internal_provider() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_label(Arg_&& arg, Args_... args);
  std::string* mutable_label();
  PROTOBUF_NODISCARD std::string* release_label();
  void set_allocated_label(std::string* value);

  private:
  const std::string& _internal_label() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_object() ;
  const ::pg_query::Node& object() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_object();
  ::pg_query::Node* mutable_object();
  void set_allocated_object(::pg_query::Node* value);
  void unsafe_arena_set_allocated_object(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_object();

  private:
  const ::pg_query::Node& _internal_object() const;
  ::pg_query::Node* _internal_mutable_object();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 1,
      43, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr provider_;
    ::google::protobuf::internal::ArenaStringPtr label_;
    ::pg_query::Node* object_;
    int objtype_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class SelectStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.SelectStmt) */ {
 public:
  inline SelectStmt() : SelectStmt(nullptr) {}
  ~SelectStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SelectStmt(::google::protobuf::internal::ConstantInitialized);

  inline SelectStmt(const SelectStmt& from)
      : SelectStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SelectStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const SelectStmt* internal_default_instance() {
    return reinterpret_cast<const SelectStmt*>(
               &_SelectStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    131;

  friend void swap(SelectStmt& a, SelectStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(SelectStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SelectStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SelectStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SelectStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SelectStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const SelectStmt& from) {
    SelectStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(SelectStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.SelectStmt";
  }
  protected:
  explicit SelectStmt(::google::protobuf::Arena* arena);
  SelectStmt(::google::protobuf::Arena* arena, const SelectStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDistinctClauseFieldNumber = 1,
    kTargetListFieldNumber = 3,
    kFromClauseFieldNumber = 4,
    kGroupClauseFieldNumber = 6,
    kWindowClauseFieldNumber = 9,
    kValuesListsFieldNumber = 10,
    kSortClauseFieldNumber = 11,
    kLockingClauseFieldNumber = 15,
    kIntoClauseFieldNumber = 2,
    kWhereClauseFieldNumber = 5,
    kHavingClauseFieldNumber = 8,
    kLimitOffsetFieldNumber = 12,
    kLimitCountFieldNumber = 13,
    kWithClauseFieldNumber = 16,
    kLargFieldNumber = 19,
    kRargFieldNumber = 20,
    kGroupDistinctFieldNumber = 7,
    kAllFieldNumber = 18,
    kLimitOptionFieldNumber = 14,
    kOpFieldNumber = 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_distinct_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_distinct_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_distinct_clause();
  public:
  const ::pg_query::Node& distinct_clause(int index) const;
  ::pg_query::Node* add_distinct_clause();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_target_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_target_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_target_list();
  public:
  const ::pg_query::Node& target_list(int index) const;
  ::pg_query::Node* add_target_list();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_from_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_from_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_from_clause();
  public:
  const ::pg_query::Node& from_clause(int index) const;
  ::pg_query::Node* add_from_clause();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_group_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_group_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_group_clause();
  public:
  const ::pg_query::Node& group_clause(int index) const;
  ::pg_query::Node* add_group_clause();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      group_clause() const;
  // repeated .pg_query.Node window_clause = 9 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_window_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_window_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_window_clause();
  public:
  const ::pg_query::Node& window_clause(int index) const;
  ::pg_query::Node* add_window_clause();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      window_clause() const;
  // repeated .pg_query.Node values_lists = 10 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_values_lists();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_values_lists() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_values_lists();
  public:
  const ::pg_query::Node& values_lists(int index) const;
  ::pg_query::Node* add_values_lists();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      values_lists() const;
  // repeated .pg_query.Node sort_clause = 11 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_sort_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_sort_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_sort_clause();
  public:
  const ::pg_query::Node& sort_clause(int index) const;
  ::pg_query::Node* add_sort_clause();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      sort_clause() const;
  // repeated .pg_query.Node locking_clause = 15 [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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_locking_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_locking_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_locking_clause();
  public:
  const ::pg_query::Node& locking_clause(int index) const;
  ::pg_query::Node* add_locking_clause();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      locking_clause() const;
  // .pg_query.IntoClause into_clause = 2 [json_name = "intoClause"];
  bool has_into_clause() const;
  void clear_into_clause() ;
  const ::pg_query::IntoClause& into_clause() const;
  PROTOBUF_NODISCARD ::pg_query::IntoClause* release_into_clause();
  ::pg_query::IntoClause* mutable_into_clause();
  void set_allocated_into_clause(::pg_query::IntoClause* value);
  void unsafe_arena_set_allocated_into_clause(::pg_query::IntoClause* value);
  ::pg_query::IntoClause* unsafe_arena_release_into_clause();

  private:
  const ::pg_query::IntoClause& _internal_into_clause() const;
  ::pg_query::IntoClause* _internal_mutable_into_clause();

  public:
  // .pg_query.Node where_clause = 5 [json_name = "whereClause"];
  bool has_where_clause() const;
  void clear_where_clause() ;
  const ::pg_query::Node& where_clause() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* value);
  void unsafe_arena_set_allocated_where_clause(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();

  public:
  // .pg_query.Node having_clause = 8 [json_name = "havingClause"];
  bool has_having_clause() const;
  void clear_having_clause() ;
  const ::pg_query::Node& having_clause() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_having_clause();
  ::pg_query::Node* mutable_having_clause();
  void set_allocated_having_clause(::pg_query::Node* value);
  void unsafe_arena_set_allocated_having_clause(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_having_clause();

  private:
  const ::pg_query::Node& _internal_having_clause() const;
  ::pg_query::Node* _internal_mutable_having_clause();

  public:
  // .pg_query.Node limit_offset = 12 [json_name = "limitOffset"];
  bool has_limit_offset() const;
  void clear_limit_offset() ;
  const ::pg_query::Node& limit_offset() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_limit_offset();
  ::pg_query::Node* mutable_limit_offset();
  void set_allocated_limit_offset(::pg_query::Node* value);
  void unsafe_arena_set_allocated_limit_offset(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_limit_offset();

  private:
  const ::pg_query::Node& _internal_limit_offset() const;
  ::pg_query::Node* _internal_mutable_limit_offset();

  public:
  // .pg_query.Node limit_count = 13 [json_name = "limitCount"];
  bool has_limit_count() const;
  void clear_limit_count() ;
  const ::pg_query::Node& limit_count() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_limit_count();
  ::pg_query::Node* mutable_limit_count();
  void set_allocated_limit_count(::pg_query::Node* value);
  void unsafe_arena_set_allocated_limit_count(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_limit_count();

  private:
  const ::pg_query::Node& _internal_limit_count() const;
  ::pg_query::Node* _internal_mutable_limit_count();

  public:
  // .pg_query.WithClause with_clause = 16 [json_name = "withClause"];
  bool has_with_clause() const;
  void clear_with_clause() ;
  const ::pg_query::WithClause& with_clause() const;
  PROTOBUF_NODISCARD ::pg_query::WithClause* release_with_clause();
  ::pg_query::WithClause* mutable_with_clause();
  void set_allocated_with_clause(::pg_query::WithClause* value);
  void unsafe_arena_set_allocated_with_clause(::pg_query::WithClause* value);
  ::pg_query::WithClause* unsafe_arena_release_with_clause();

  private:
  const ::pg_query::WithClause& _internal_with_clause() const;
  ::pg_query::WithClause* _internal_mutable_with_clause();

  public:
  // .pg_query.SelectStmt larg = 19 [json_name = "larg"];
  bool has_larg() const;
  void clear_larg() ;
  const ::pg_query::SelectStmt& larg() const;
  PROTOBUF_NODISCARD ::pg_query::SelectStmt* release_larg();
  ::pg_query::SelectStmt* mutable_larg();
  void set_allocated_larg(::pg_query::SelectStmt* value);
  void unsafe_arena_set_allocated_larg(::pg_query::SelectStmt* value);
  ::pg_query::SelectStmt* unsafe_arena_release_larg();

  private:
  const ::pg_query::SelectStmt& _internal_larg() const;
  ::pg_query::SelectStmt* _internal_mutable_larg();

  public:
  // .pg_query.SelectStmt rarg = 20 [json_name = "rarg"];
  bool has_rarg() const;
  void clear_rarg() ;
  const ::pg_query::SelectStmt& rarg() const;
  PROTOBUF_NODISCARD ::pg_query::SelectStmt* release_rarg();
  ::pg_query::SelectStmt* mutable_rarg();
  void set_allocated_rarg(::pg_query::SelectStmt* value);
  void unsafe_arena_set_allocated_rarg(::pg_query::SelectStmt* value);
  ::pg_query::SelectStmt* unsafe_arena_release_rarg();

  private:
  const ::pg_query::SelectStmt& _internal_rarg() const;
  ::pg_query::SelectStmt* _internal_mutable_rarg();

  public:
  // bool group_distinct = 7 [json_name = "groupDistinct"];
  void clear_group_distinct() ;
  bool group_distinct() const;
  void set_group_distinct(bool value);

  private:
  bool _internal_group_distinct() const;
  void _internal_set_group_distinct(bool value);

  public:
  // bool all = 18 [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:
  // .pg_query.LimitOption limit_option = 14 [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 = 17 [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:
  // @@protoc_insertion_point(class_scope:pg_query.SelectStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      5, 20, 16,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > distinct_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > target_list_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > from_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > group_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > window_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > values_lists_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > sort_clause_;
    ::google::protobuf::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_;
    bool group_distinct_;
    bool all_;
    int limit_option_;
    int op_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class SetOperationStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.SetOperationStmt) */ {
 public:
  inline SetOperationStmt() : SetOperationStmt(nullptr) {}
  ~SetOperationStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SetOperationStmt(::google::protobuf::internal::ConstantInitialized);

  inline SetOperationStmt(const SetOperationStmt& from)
      : SetOperationStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SetOperationStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const SetOperationStmt* internal_default_instance() {
    return reinterpret_cast<const SetOperationStmt*>(
               &_SetOperationStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    132;

  friend void swap(SetOperationStmt& a, SetOperationStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(SetOperationStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SetOperationStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SetOperationStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SetOperationStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SetOperationStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const SetOperationStmt& from) {
    SetOperationStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(SetOperationStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.SetOperationStmt";
  }
  protected:
  explicit SetOperationStmt(::google::protobuf::Arena* arena);
  SetOperationStmt(::google::protobuf::Arena* arena, const SetOperationStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_col_types();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_col_types() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_col_types();
  public:
  const ::pg_query::Node& col_types(int index) const;
  ::pg_query::Node* add_col_types();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_col_typmods();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_col_typmods() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_col_typmods();
  public:
  const ::pg_query::Node& col_typmods(int index) const;
  ::pg_query::Node* add_col_typmods();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_col_collations();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_col_collations() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_col_collations();
  public:
  const ::pg_query::Node& col_collations(int index) const;
  ::pg_query::Node* add_col_collations();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_group_clauses();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_group_clauses() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_group_clauses();
  public:
  const ::pg_query::Node& group_clauses(int index) const;
  ::pg_query::Node* add_group_clauses();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      group_clauses() const;
  // .pg_query.Node larg = 3 [json_name = "larg"];
  bool has_larg() const;
  void clear_larg() ;
  const ::pg_query::Node& larg() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_larg();
  ::pg_query::Node* mutable_larg();
  void set_allocated_larg(::pg_query::Node* value);
  void unsafe_arena_set_allocated_larg(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_larg();

  private:
  const ::pg_query::Node& _internal_larg() const;
  ::pg_query::Node* _internal_mutable_larg();

  public:
  // .pg_query.Node rarg = 4 [json_name = "rarg"];
  bool has_rarg() const;
  void clear_rarg() ;
  const ::pg_query::Node& rarg() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_rarg();
  ::pg_query::Node* mutable_rarg();
  void set_allocated_rarg(::pg_query::Node* value);
  void unsafe_arena_set_allocated_rarg(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_rarg();

  private:
  const ::pg_query::Node& _internal_rarg() const;
  ::pg_query::Node* _internal_mutable_rarg();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 6,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > col_types_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > col_typmods_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > col_collations_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > group_clauses_;
    ::pg_query::Node* larg_;
    ::pg_query::Node* rarg_;
    int op_;
    bool all_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class SetToDefault final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.SetToDefault) */ {
 public:
  inline SetToDefault() : SetToDefault(nullptr) {}
  ~SetToDefault() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SetToDefault(::google::protobuf::internal::ConstantInitialized);

  inline SetToDefault(const SetToDefault& from)
      : SetToDefault(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SetToDefault& default_instance() {
    return *internal_default_instance();
  }
  static inline const SetToDefault* internal_default_instance() {
    return reinterpret_cast<const SetToDefault*>(
               &_SetToDefault_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    58;

  friend void swap(SetToDefault& a, SetToDefault& b) {
    a.Swap(&b);
  }
  inline void Swap(SetToDefault* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SetToDefault* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SetToDefault* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SetToDefault>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SetToDefault& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const SetToDefault& from) {
    SetToDefault::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(SetToDefault* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.SetToDefault";
  }
  protected:
  explicit SetToDefault(::google::protobuf::Arena* arena);
  SetToDefault(::google::protobuf::Arena* arena, const SetToDefault& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // uint32 type_id = 2 [json_name = "typeId"];
  void clear_type_id() ;
  ::uint32_t type_id() const;
  void set_type_id(::uint32_t value);

  private:
  ::uint32_t _internal_type_id() const;
  void _internal_set_type_id(::uint32_t value);

  public:
  // int32 type_mod = 3 [json_name = "typeMod"];
  void clear_type_mod() ;
  ::int32_t type_mod() const;
  void set_type_mod(::int32_t value);

  private:
  ::int32_t _internal_type_mod() const;
  void _internal_set_type_mod(::int32_t value);

  public:
  // uint32 collation = 4 [json_name = "collation"];
  void clear_collation() ;
  ::uint32_t collation() const;
  void set_collation(::uint32_t value);

  private:
  ::uint32_t _internal_collation() const;
  void _internal_set_collation(::uint32_t value);

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.SetToDefault)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* xpr_;
    ::uint32_t type_id_;
    ::int32_t type_mod_;
    ::uint32_t collation_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class SortBy final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.SortBy) */ {
 public:
  inline SortBy() : SortBy(nullptr) {}
  ~SortBy() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SortBy(::google::protobuf::internal::ConstantInitialized);

  inline SortBy(const SortBy& from)
      : SortBy(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SortBy& default_instance() {
    return *internal_default_instance();
  }
  static inline const SortBy* internal_default_instance() {
    return reinterpret_cast<const SortBy*>(
               &_SortBy_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    82;

  friend void swap(SortBy& a, SortBy& b) {
    a.Swap(&b);
  }
  inline void Swap(SortBy* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SortBy* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SortBy* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SortBy>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SortBy& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const SortBy& from) {
    SortBy::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(SortBy* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.SortBy";
  }
  protected:
  explicit SortBy(::google::protobuf::Arena* arena);
  SortBy(::google::protobuf::Arena* arena, const SortBy& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_use_op();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_use_op() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_use_op();
  public:
  const ::pg_query::Node& use_op(int index) const;
  ::pg_query::Node* add_use_op();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      use_op() const;
  // .pg_query.Node node = 1 [json_name = "node"];
  bool has_node() const;
  void clear_node() ;
  const ::pg_query::Node& node() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_node();
  ::pg_query::Node* mutable_node();
  void set_allocated_node(::pg_query::Node* value);
  void unsafe_arena_set_allocated_node(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_node();

  private:
  const ::pg_query::Node& _internal_node() const;
  ::pg_query::Node* _internal_mutable_node();

  public:
  // .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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.SortBy)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > use_op_;
    ::pg_query::Node* node_;
    int sortby_dir_;
    int sortby_nulls_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class StatsElem final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.StatsElem) */ {
 public:
  inline StatsElem() : StatsElem(nullptr) {}
  ~StatsElem() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR StatsElem(::google::protobuf::internal::ConstantInitialized);

  inline StatsElem(const StatsElem& from)
      : StatsElem(nullptr, from) {}
  StatsElem(StatsElem&& from) noexcept
    : StatsElem() {
    *this = ::std::move(from);
  }

  inline StatsElem& operator=(const StatsElem& from) {
    CopyFrom(from);
    return *this;
  }
  inline StatsElem& operator=(StatsElem&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const StatsElem& default_instance() {
    return *internal_default_instance();
  }
  static inline const StatsElem* internal_default_instance() {
    return reinterpret_cast<const StatsElem*>(
               &_StatsElem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    195;

  friend void swap(StatsElem& a, StatsElem& b) {
    a.Swap(&b);
  }
  inline void Swap(StatsElem* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(StatsElem* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  StatsElem* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<StatsElem>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const StatsElem& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const StatsElem& from) {
    StatsElem::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(StatsElem* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.StatsElem";
  }
  protected:
  explicit StatsElem(::google::protobuf::Arena* arena);
  StatsElem(::google::protobuf::Arena* arena, const StatsElem& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kExprFieldNumber = 2,
  };
  // string name = 1 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .pg_query.Node expr = 2 [json_name = "expr"];
  bool has_expr() const;
  void clear_expr() ;
  const ::pg_query::Node& expr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_expr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_expr();

  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();

  public:
  // @@protoc_insertion_point(class_scope:pg_query.StatsElem)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      31, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::pg_query::Node* expr_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class SubLink final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.SubLink) */ {
 public:
  inline SubLink() : SubLink(nullptr) {}
  ~SubLink() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SubLink(::google::protobuf::internal::ConstantInitialized);

  inline SubLink(const SubLink& from)
      : SubLink(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SubLink& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SubLink* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SubLink* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SubLink>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SubLink& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const SubLink& from) {
    SubLink::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(SubLink* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.SubLink";
  }
  protected:
  explicit SubLink(::google::protobuf::Arena* arena);
  SubLink(::google::protobuf::Arena* arena, const SubLink& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_oper_name();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_oper_name() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_oper_name();
  public:
  const ::pg_query::Node& oper_name(int index) const;
  ::pg_query::Node* add_oper_name();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      oper_name() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node testexpr = 4 [json_name = "testexpr"];
  bool has_testexpr() const;
  void clear_testexpr() ;
  const ::pg_query::Node& testexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_testexpr();
  ::pg_query::Node* mutable_testexpr();
  void set_allocated_testexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_testexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_testexpr();

  private:
  const ::pg_query::Node& _internal_testexpr() const;
  ::pg_query::Node* _internal_mutable_testexpr();

  public:
  // .pg_query.Node subselect = 6 [json_name = "subselect"];
  bool has_subselect() const;
  void clear_subselect() ;
  const ::pg_query::Node& subselect() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_subselect();
  ::pg_query::Node* mutable_subselect();
  void set_allocated_subselect(::pg_query::Node* value);
  void unsafe_arena_set_allocated_subselect(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_subselect();

  private:
  const ::pg_query::Node& _internal_subselect() const;
  ::pg_query::Node* _internal_mutable_subselect();

  public:
  // .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() ;
  ::int32_t sub_link_id() const;
  void set_sub_link_id(::int32_t value);

  private:
  ::int32_t _internal_sub_link_id() const;
  void _internal_set_sub_link_id(::int32_t value);

  public:
  // int32 location = 7 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.SubLink)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 4,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > oper_name_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* testexpr_;
    ::pg_query::Node* subselect_;
    int sub_link_type_;
    ::int32_t sub_link_id_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class SubPlan final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.SubPlan) */ {
 public:
  inline SubPlan() : SubPlan(nullptr) {}
  ~SubPlan() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SubPlan(::google::protobuf::internal::ConstantInitialized);

  inline SubPlan(const SubPlan& from)
      : SubPlan(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SubPlan& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SubPlan* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SubPlan* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SubPlan>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SubPlan& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const SubPlan& from) {
    SubPlan::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(SubPlan* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.SubPlan";
  }
  protected:
  explicit SubPlan(::google::protobuf::Arena* arena);
  SubPlan(::google::protobuf::Arena* arena, const SubPlan& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_param_ids();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_param_ids() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_param_ids();
  public:
  const ::pg_query::Node& param_ids(int index) const;
  ::pg_query::Node* add_param_ids();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_set_param();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_set_param() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_set_param();
  public:
  const ::pg_query::Node& set_param(int index) const;
  ::pg_query::Node* add_set_param();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_par_param();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_par_param() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_par_param();
  public:
  const ::pg_query::Node& par_param(int index) const;
  ::pg_query::Node* add_par_param();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // string plan_name = 6 [json_name = "plan_name"];
  void clear_plan_name() ;
  const std::string& plan_name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_plan_name(Arg_&& arg, Args_... args);
  std::string* mutable_plan_name();
  PROTOBUF_NODISCARD std::string* release_plan_name();
  void set_allocated_plan_name(std::string* value);

  private:
  const std::string& _internal_plan_name() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node testexpr = 3 [json_name = "testexpr"];
  bool has_testexpr() const;
  void clear_testexpr() ;
  const ::pg_query::Node& testexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_testexpr();
  ::pg_query::Node* mutable_testexpr();
  void set_allocated_testexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_testexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_testexpr();

  private:
  const ::pg_query::Node& _internal_testexpr() const;
  ::pg_query::Node* _internal_mutable_testexpr();

  public:
  // .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() ;
  ::int32_t plan_id() const;
  void set_plan_id(::int32_t value);

  private:
  ::int32_t _internal_plan_id() const;
  void _internal_set_plan_id(::int32_t value);

  public:
  // uint32 first_col_type = 7 [json_name = "firstColType"];
  void clear_first_col_type() ;
  ::uint32_t first_col_type() const;
  void set_first_col_type(::uint32_t value);

  private:
  ::uint32_t _internal_first_col_type() const;
  void _internal_set_first_col_type(::uint32_t value);

  public:
  // int32 first_col_typmod = 8 [json_name = "firstColTypmod"];
  void clear_first_col_typmod() ;
  ::int32_t first_col_typmod() const;
  void set_first_col_typmod(::int32_t value);

  private:
  ::int32_t _internal_first_col_typmod() const;
  void _internal_set_first_col_typmod(::int32_t value);

  public:
  // uint32 first_col_collation = 9 [json_name = "firstColCollation"];
  void clear_first_col_collation() ;
  ::uint32_t first_col_collation() const;
  void set_first_col_collation(::uint32_t value);

  private:
  ::uint32_t _internal_first_col_collation() const;
  void _internal_set_first_col_collation(::uint32_t 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      5, 17, 6,
      50, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > param_ids_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > set_param_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > par_param_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::google::protobuf::internal::ArenaStringPtr plan_name_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* testexpr_;
    int sub_link_type_;
    ::int32_t plan_id_;
    ::uint32_t first_col_type_;
    ::int32_t first_col_typmod_;
    ::uint32_t first_col_collation_;
    bool use_hash_table_;
    bool unknown_eq_false_;
    bool parallel_safe_;
    double startup_cost_;
    double per_call_cost_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class SubscriptingRef final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.SubscriptingRef) */ {
 public:
  inline SubscriptingRef() : SubscriptingRef(nullptr) {}
  ~SubscriptingRef() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SubscriptingRef(::google::protobuf::internal::ConstantInitialized);

  inline SubscriptingRef(const SubscriptingRef& from)
      : SubscriptingRef(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SubscriptingRef& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SubscriptingRef* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SubscriptingRef* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SubscriptingRef>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SubscriptingRef& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const SubscriptingRef& from) {
    SubscriptingRef::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(SubscriptingRef* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.SubscriptingRef";
  }
  protected:
  explicit SubscriptingRef(::google::protobuf::Arena* arena);
  SubscriptingRef(::google::protobuf::Arena* arena, const SubscriptingRef& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRefupperindexprFieldNumber = 7,
    kReflowerindexprFieldNumber = 8,
    kXprFieldNumber = 1,
    kRefexprFieldNumber = 9,
    kRefassgnexprFieldNumber = 10,
    kRefcontainertypeFieldNumber = 2,
    kRefelemtypeFieldNumber = 3,
    kRefrestypeFieldNumber = 4,
    kReftypmodFieldNumber = 5,
    kRefcollidFieldNumber = 6,
  };
  // repeated .pg_query.Node refupperindexpr = 7 [json_name = "refupperindexpr"];
  int refupperindexpr_size() const;
  private:
  int _internal_refupperindexpr_size() const;

  public:
  void clear_refupperindexpr() ;
  ::pg_query::Node* mutable_refupperindexpr(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_refupperindexpr();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_refupperindexpr() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_refupperindexpr();
  public:
  const ::pg_query::Node& refupperindexpr(int index) const;
  ::pg_query::Node* add_refupperindexpr();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      refupperindexpr() const;
  // repeated .pg_query.Node reflowerindexpr = 8 [json_name = "reflowerindexpr"];
  int reflowerindexpr_size() const;
  private:
  int _internal_reflowerindexpr_size() const;

  public:
  void clear_reflowerindexpr() ;
  ::pg_query::Node* mutable_reflowerindexpr(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_reflowerindexpr();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_reflowerindexpr() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_reflowerindexpr();
  public:
  const ::pg_query::Node& reflowerindexpr(int index) const;
  ::pg_query::Node* add_reflowerindexpr();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      reflowerindexpr() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node refexpr = 9 [json_name = "refexpr"];
  bool has_refexpr() const;
  void clear_refexpr() ;
  const ::pg_query::Node& refexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_refexpr();
  ::pg_query::Node* mutable_refexpr();
  void set_allocated_refexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_refexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_refexpr();

  private:
  const ::pg_query::Node& _internal_refexpr() const;
  ::pg_query::Node* _internal_mutable_refexpr();

  public:
  // .pg_query.Node refassgnexpr = 10 [json_name = "refassgnexpr"];
  bool has_refassgnexpr() const;
  void clear_refassgnexpr() ;
  const ::pg_query::Node& refassgnexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_refassgnexpr();
  ::pg_query::Node* mutable_refassgnexpr();
  void set_allocated_refassgnexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_refassgnexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_refassgnexpr();

  private:
  const ::pg_query::Node& _internal_refassgnexpr() const;
  ::pg_query::Node* _internal_mutable_refassgnexpr();

  public:
  // uint32 refcontainertype = 2 [json_name = "refcontainertype"];
  void clear_refcontainertype() ;
  ::uint32_t refcontainertype() const;
  void set_refcontainertype(::uint32_t value);

  private:
  ::uint32_t _internal_refcontainertype() const;
  void _internal_set_refcontainertype(::uint32_t value);

  public:
  // uint32 refelemtype = 3 [json_name = "refelemtype"];
  void clear_refelemtype() ;
  ::uint32_t refelemtype() const;
  void set_refelemtype(::uint32_t value);

  private:
  ::uint32_t _internal_refelemtype() const;
  void _internal_set_refelemtype(::uint32_t value);

  public:
  // uint32 refrestype = 4 [json_name = "refrestype"];
  void clear_refrestype() ;
  ::uint32_t refrestype() const;
  void set_refrestype(::uint32_t value);

  private:
  ::uint32_t _internal_refrestype() const;
  void _internal_set_refrestype(::uint32_t value);

  public:
  // int32 reftypmod = 5 [json_name = "reftypmod"];
  void clear_reftypmod() ;
  ::int32_t reftypmod() const;
  void set_reftypmod(::int32_t value);

  private:
  ::int32_t _internal_reftypmod() const;
  void _internal_set_reftypmod(::int32_t value);

  public:
  // uint32 refcollid = 6 [json_name = "refcollid"];
  void clear_refcollid() ;
  ::uint32_t refcollid() const;
  void set_refcollid(::uint32_t value);

  private:
  ::uint32_t _internal_refcollid() const;
  void _internal_set_refcollid(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.SubscriptingRef)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 10, 5,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > refupperindexpr_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > reflowerindexpr_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* refexpr_;
    ::pg_query::Node* refassgnexpr_;
    ::uint32_t refcontainertype_;
    ::uint32_t refelemtype_;
    ::uint32_t refrestype_;
    ::int32_t reftypmod_;
    ::uint32_t refcollid_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class TableFunc final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.TableFunc) */ {
 public:
  inline TableFunc() : TableFunc(nullptr) {}
  ~TableFunc() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR TableFunc(::google::protobuf::internal::ConstantInitialized);

  inline TableFunc(const TableFunc& from)
      : TableFunc(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TableFunc& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TableFunc* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TableFunc* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TableFunc>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TableFunc& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const TableFunc& from) {
    TableFunc::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(TableFunc* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.TableFunc";
  }
  protected:
  explicit TableFunc(::google::protobuf::Arena* arena);
  TableFunc(::google::protobuf::Arena* arena, const TableFunc& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNsUrisFieldNumber = 1,
    kNsNamesFieldNumber = 2,
    kColnamesFieldNumber = 5,
    kColtypesFieldNumber = 6,
    kColtypmodsFieldNumber = 7,
    kColcollationsFieldNumber = 8,
    kColexprsFieldNumber = 9,
    kColdefexprsFieldNumber = 10,
    kNotnullsFieldNumber = 11,
    kDocexprFieldNumber = 3,
    kRowexprFieldNumber = 4,
    kOrdinalitycolFieldNumber = 12,
    kLocationFieldNumber = 13,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_ns_uris();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_ns_uris() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_ns_uris();
  public:
  const ::pg_query::Node& ns_uris(int index) const;
  ::pg_query::Node* add_ns_uris();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_ns_names();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_ns_names() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_ns_names();
  public:
  const ::pg_query::Node& ns_names(int index) const;
  ::pg_query::Node* add_ns_names();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_colnames();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_colnames() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_colnames();
  public:
  const ::pg_query::Node& colnames(int index) const;
  ::pg_query::Node* add_colnames();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_coltypes();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_coltypes() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_coltypes();
  public:
  const ::pg_query::Node& coltypes(int index) const;
  ::pg_query::Node* add_coltypes();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_coltypmods();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_coltypmods() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_coltypmods();
  public:
  const ::pg_query::Node& coltypmods(int index) const;
  ::pg_query::Node* add_coltypmods();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_colcollations();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_colcollations() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_colcollations();
  public:
  const ::pg_query::Node& colcollations(int index) const;
  ::pg_query::Node* add_colcollations();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_colexprs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_colexprs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_colexprs();
  public:
  const ::pg_query::Node& colexprs(int index) const;
  ::pg_query::Node* add_colexprs();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_coldefexprs();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_coldefexprs() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_coldefexprs();
  public:
  const ::pg_query::Node& coldefexprs(int index) const;
  ::pg_query::Node* add_coldefexprs();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      coldefexprs() const;
  // repeated uint64 notnulls = 11 [json_name = "notnulls"];
  int notnulls_size() const;
  private:
  int _internal_notnulls_size() const;

  public:
  void clear_notnulls() ;
  ::uint64_t notnulls(int index) const;
  void set_notnulls(int index, ::uint64_t value);
  void add_notnulls(::uint64_t value);
  const ::google::protobuf::RepeatedField<::uint64_t>& notnulls() const;
  ::google::protobuf::RepeatedField<::uint64_t>* mutable_notnulls();

  private:
  const ::google::protobuf::RepeatedField<::uint64_t>& _internal_notnulls() const;
  ::google::protobuf::RepeatedField<::uint64_t>* _internal_mutable_notnulls();

  public:
  // .pg_query.Node docexpr = 3 [json_name = "docexpr"];
  bool has_docexpr() const;
  void clear_docexpr() ;
  const ::pg_query::Node& docexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_docexpr();
  ::pg_query::Node* mutable_docexpr();
  void set_allocated_docexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_docexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_docexpr();

  private:
  const ::pg_query::Node& _internal_docexpr() const;
  ::pg_query::Node* _internal_mutable_docexpr();

  public:
  // .pg_query.Node rowexpr = 4 [json_name = "rowexpr"];
  bool has_rowexpr() const;
  void clear_rowexpr() ;
  const ::pg_query::Node& rowexpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_rowexpr();
  ::pg_query::Node* mutable_rowexpr();
  void set_allocated_rowexpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_rowexpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_rowexpr();

  private:
  const ::pg_query::Node& _internal_rowexpr() const;
  ::pg_query::Node* _internal_mutable_rowexpr();

  public:
  // int32 ordinalitycol = 12 [json_name = "ordinalitycol"];
  void clear_ordinalitycol() ;
  ::int32_t ordinalitycol() const;
  void set_ordinalitycol(::int32_t value);

  private:
  ::int32_t _internal_ordinalitycol() const;
  void _internal_set_ordinalitycol(::int32_t value);

  public:
  // int32 location = 13 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.TableFunc)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 13, 10,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > ns_uris_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > ns_names_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > colnames_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > coltypes_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > coltypmods_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > colcollations_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > colexprs_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > coldefexprs_;
    ::google::protobuf::RepeatedField<::uint64_t> notnulls_;
    mutable ::google::protobuf::internal::CachedSize _notnulls_cached_byte_size_;
    ::pg_query::Node* docexpr_;
    ::pg_query::Node* rowexpr_;
    ::int32_t ordinalitycol_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class TableLikeClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.TableLikeClause) */ {
 public:
  inline TableLikeClause() : TableLikeClause(nullptr) {}
  ~TableLikeClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR TableLikeClause(::google::protobuf::internal::ConstantInitialized);

  inline TableLikeClause(const TableLikeClause& from)
      : TableLikeClause(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TableLikeClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const TableLikeClause* internal_default_instance() {
    return reinterpret_cast<const TableLikeClause*>(
               &_TableLikeClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    90;

  friend void swap(TableLikeClause& a, TableLikeClause& b) {
    a.Swap(&b);
  }
  inline void Swap(TableLikeClause* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TableLikeClause* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TableLikeClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TableLikeClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TableLikeClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const TableLikeClause& from) {
    TableLikeClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(TableLikeClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.TableLikeClause";
  }
  protected:
  explicit TableLikeClause(::google::protobuf::Arena* arena);
  TableLikeClause(::google::protobuf::Arena* arena, const TableLikeClause& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRelationFieldNumber = 1,
    kOptionsFieldNumber = 2,
    kRelationOidFieldNumber = 3,
  };
  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // uint32 options = 2 [json_name = "options"];
  void clear_options() ;
  ::uint32_t options() const;
  void set_options(::uint32_t value);

  private:
  ::uint32_t _internal_options() const;
  void _internal_set_options(::uint32_t value);

  public:
  // uint32 relation_oid = 3 [json_name = "relationOid"];
  void clear_relation_oid() ;
  ::uint32_t relation_oid() const;
  void set_relation_oid(::uint32_t value);

  private:
  ::uint32_t _internal_relation_oid() const;
  void _internal_set_relation_oid(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.TableLikeClause)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::RangeVar* relation_;
    ::uint32_t options_;
    ::uint32_t relation_oid_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class TableSampleClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.TableSampleClause) */ {
 public:
  inline TableSampleClause() : TableSampleClause(nullptr) {}
  ~TableSampleClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR TableSampleClause(::google::protobuf::internal::ConstantInitialized);

  inline TableSampleClause(const TableSampleClause& from)
      : TableSampleClause(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TableSampleClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const TableSampleClause* internal_default_instance() {
    return reinterpret_cast<const TableSampleClause*>(
               &_TableSampleClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    103;

  friend void swap(TableSampleClause& a, TableSampleClause& b) {
    a.Swap(&b);
  }
  inline void Swap(TableSampleClause* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TableSampleClause* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TableSampleClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TableSampleClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TableSampleClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const TableSampleClause& from) {
    TableSampleClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(TableSampleClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.TableSampleClause";
  }
  protected:
  explicit TableSampleClause(::google::protobuf::Arena* arena);
  TableSampleClause(::google::protobuf::Arena* arena, const TableSampleClause& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node repeatable = 3 [json_name = "repeatable"];
  bool has_repeatable() const;
  void clear_repeatable() ;
  const ::pg_query::Node& repeatable() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_repeatable();
  ::pg_query::Node* mutable_repeatable();
  void set_allocated_repeatable(::pg_query::Node* value);
  void unsafe_arena_set_allocated_repeatable(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_repeatable();

  private:
  const ::pg_query::Node& _internal_repeatable() const;
  ::pg_query::Node* _internal_mutable_repeatable();

  public:
  // uint32 tsmhandler = 1 [json_name = "tsmhandler"];
  void clear_tsmhandler() ;
  ::uint32_t tsmhandler() const;
  void set_tsmhandler(::uint32_t value);

  private:
  ::uint32_t _internal_tsmhandler() const;
  void _internal_set_tsmhandler(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.TableSampleClause)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* repeatable_;
    ::uint32_t tsmhandler_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class TargetEntry final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.TargetEntry) */ {
 public:
  inline TargetEntry() : TargetEntry(nullptr) {}
  ~TargetEntry() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR TargetEntry(::google::protobuf::internal::ConstantInitialized);

  inline TargetEntry(const TargetEntry& from)
      : TargetEntry(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TargetEntry& default_instance() {
    return *internal_default_instance();
  }
  static inline const TargetEntry* internal_default_instance() {
    return reinterpret_cast<const TargetEntry*>(
               &_TargetEntry_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    62;

  friend void swap(TargetEntry& a, TargetEntry& b) {
    a.Swap(&b);
  }
  inline void Swap(TargetEntry* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TargetEntry* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TargetEntry* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TargetEntry>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TargetEntry& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const TargetEntry& from) {
    TargetEntry::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(TargetEntry* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.TargetEntry";
  }
  protected:
  explicit TargetEntry(::google::protobuf::Arena* arena);
  TargetEntry(::google::protobuf::Arena* arena, const TargetEntry& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_resname(Arg_&& arg, Args_... args);
  std::string* mutable_resname();
  PROTOBUF_NODISCARD std::string* release_resname();
  void set_allocated_resname(std::string* value);

  private:
  const std::string& _internal_resname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node expr = 2 [json_name = "expr"];
  bool has_expr() const;
  void clear_expr() ;
  const ::pg_query::Node& expr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_expr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_expr();

  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();

  public:
  // int32 resno = 3 [json_name = "resno"];
  void clear_resno() ;
  ::int32_t resno() const;
  void set_resno(::int32_t value);

  private:
  ::int32_t _internal_resno() const;
  void _internal_set_resno(::int32_t value);

  public:
  // uint32 ressortgroupref = 5 [json_name = "ressortgroupref"];
  void clear_ressortgroupref() ;
  ::uint32_t ressortgroupref() const;
  void set_ressortgroupref(::uint32_t value);

  private:
  ::uint32_t _internal_ressortgroupref() const;
  void _internal_set_ressortgroupref(::uint32_t value);

  public:
  // uint32 resorigtbl = 6 [json_name = "resorigtbl"];
  void clear_resorigtbl() ;
  ::uint32_t resorigtbl() const;
  void set_resorigtbl(::uint32_t value);

  private:
  ::uint32_t _internal_resorigtbl() const;
  void _internal_set_resorigtbl(::uint32_t value);

  public:
  // int32 resorigcol = 7 [json_name = "resorigcol"];
  void clear_resorigcol() ;
  ::int32_t resorigcol() const;
  void set_resorigcol(::int32_t value);

  private:
  ::int32_t _internal_resorigcol() const;
  void _internal_set_resorigcol(::int32_t 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 2,
      44, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr resname_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* expr_;
    ::int32_t resno_;
    ::uint32_t ressortgroupref_;
    ::uint32_t resorigtbl_;
    ::int32_t resorigcol_;
    bool resjunk_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class TransactionStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.TransactionStmt) */ {
 public:
  inline TransactionStmt() : TransactionStmt(nullptr) {}
  ~TransactionStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR TransactionStmt(::google::protobuf::internal::ConstantInitialized);

  inline TransactionStmt(const TransactionStmt& from)
      : TransactionStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TransactionStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const TransactionStmt* internal_default_instance() {
    return reinterpret_cast<const TransactionStmt*>(
               &_TransactionStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    214;

  friend void swap(TransactionStmt& a, TransactionStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(TransactionStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TransactionStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TransactionStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TransactionStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TransactionStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const TransactionStmt& from) {
    TransactionStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(TransactionStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.TransactionStmt";
  }
  protected:
  explicit TransactionStmt(::google::protobuf::Arena* arena);
  TransactionStmt(::google::protobuf::Arena* arena, const TransactionStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // string savepoint_name = 3 [json_name = "savepoint_name"];
  void clear_savepoint_name() ;
  const std::string& savepoint_name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_savepoint_name(Arg_&& arg, Args_... args);
  std::string* mutable_savepoint_name();
  PROTOBUF_NODISCARD std::string* release_savepoint_name();
  void set_allocated_savepoint_name(std::string* value);

  private:
  const std::string& _internal_savepoint_name() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_gid(Arg_&& arg, Args_... args);
  std::string* mutable_gid();
  PROTOBUF_NODISCARD std::string* release_gid();
  void set_allocated_gid(std::string* value);

  private:
  const std::string& _internal_gid() const;
  inline PROTOBUF_ALWAYS_INLINE 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 1,
      50, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::internal::ArenaStringPtr savepoint_name_;
    ::google::protobuf::internal::ArenaStringPtr gid_;
    int kind_;
    bool chain_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class TruncateStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.TruncateStmt) */ {
 public:
  inline TruncateStmt() : TruncateStmt(nullptr) {}
  ~TruncateStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR TruncateStmt(::google::protobuf::internal::ConstantInitialized);

  inline TruncateStmt(const TruncateStmt& from)
      : TruncateStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TruncateStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const TruncateStmt* internal_default_instance() {
    return reinterpret_cast<const TruncateStmt*>(
               &_TruncateStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    187;

  friend void swap(TruncateStmt& a, TruncateStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(TruncateStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TruncateStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TruncateStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TruncateStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TruncateStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const TruncateStmt& from) {
    TruncateStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(TruncateStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.TruncateStmt";
  }
  protected:
  explicit TruncateStmt(::google::protobuf::Arena* arena);
  TruncateStmt(::google::protobuf::Arena* arena, const TruncateStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_relations();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_relations() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_relations();
  public:
  const ::pg_query::Node& relations(int index) const;
  ::pg_query::Node* add_relations();
  const ::google::protobuf::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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > relations_;
    bool restart_seqs_;
    int behavior_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class TypeCast final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.TypeCast) */ {
 public:
  inline TypeCast() : TypeCast(nullptr) {}
  ~TypeCast() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR TypeCast(::google::protobuf::internal::ConstantInitialized);

  inline TypeCast(const TypeCast& from)
      : TypeCast(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TypeCast& default_instance() {
    return *internal_default_instance();
  }
  static inline const TypeCast* internal_default_instance() {
    return reinterpret_cast<const TypeCast*>(
               &_TypeCast_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    72;

  friend void swap(TypeCast& a, TypeCast& b) {
    a.Swap(&b);
  }
  inline void Swap(TypeCast* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TypeCast* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TypeCast* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TypeCast>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TypeCast& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const TypeCast& from) {
    TypeCast::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(TypeCast* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.TypeCast";
  }
  protected:
  explicit TypeCast(::google::protobuf::Arena* arena);
  TypeCast(::google::protobuf::Arena* arena, const TypeCast& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kArgFieldNumber = 1,
    kTypeNameFieldNumber = 2,
    kLocationFieldNumber = 3,
  };
  // .pg_query.Node arg = 1 [json_name = "arg"];
  bool has_arg() const;
  void clear_arg() ;
  const ::pg_query::Node& arg() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_arg();
  ::pg_query::Node* mutable_arg();
  void set_allocated_arg(::pg_query::Node* value);
  void unsafe_arena_set_allocated_arg(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_arg();

  private:
  const ::pg_query::Node& _internal_arg() const;
  ::pg_query::Node* _internal_mutable_arg();

  public:
  // .pg_query.TypeName type_name = 2 [json_name = "typeName"];
  bool has_type_name() const;
  void clear_type_name() ;
  const ::pg_query::TypeName& type_name() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_type_name(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();

  public:
  // int32 location = 3 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.TypeCast)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* arg_;
    ::pg_query::TypeName* type_name_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class TypeName final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.TypeName) */ {
 public:
  inline TypeName() : TypeName(nullptr) {}
  ~TypeName() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR TypeName(::google::protobuf::internal::ConstantInitialized);

  inline TypeName(const TypeName& from)
      : TypeName(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TypeName& default_instance() {
    return *internal_default_instance();
  }
  static inline const TypeName* internal_default_instance() {
    return reinterpret_cast<const TypeName*>(
               &_TypeName_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    68;

  friend void swap(TypeName& a, TypeName& b) {
    a.Swap(&b);
  }
  inline void Swap(TypeName* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TypeName* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TypeName* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TypeName>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TypeName& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const TypeName& from) {
    TypeName::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(TypeName* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.TypeName";
  }
  protected:
  explicit TypeName(::google::protobuf::Arena* arena);
  TypeName(::google::protobuf::Arena* arena, const TypeName& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_names();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_names() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_names();
  public:
  const ::pg_query::Node& names(int index) const;
  ::pg_query::Node* add_names();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_typmods();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_typmods() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_typmods();
  public:
  const ::pg_query::Node& typmods(int index) const;
  ::pg_query::Node* add_typmods();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_array_bounds();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_array_bounds() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_array_bounds();
  public:
  const ::pg_query::Node& array_bounds(int index) const;
  ::pg_query::Node* add_array_bounds();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      array_bounds() const;
  // uint32 type_oid = 2 [json_name = "typeOid"];
  void clear_type_oid() ;
  ::uint32_t type_oid() const;
  void set_type_oid(::uint32_t value);

  private:
  ::uint32_t _internal_type_oid() const;
  void _internal_set_type_oid(::uint32_t 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() ;
  ::int32_t typemod() const;
  void set_typemod(::int32_t value);

  private:
  ::int32_t _internal_typemod() const;
  void _internal_set_typemod(::int32_t value);

  public:
  // int32 location = 8 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.TypeName)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > names_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > typmods_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > array_bounds_;
    ::uint32_t type_oid_;
    bool setof_;
    bool pct_type_;
    ::int32_t typemod_;
    ::int32_t location_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class UpdateStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.UpdateStmt) */ {
 public:
  inline UpdateStmt() : UpdateStmt(nullptr) {}
  ~UpdateStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR UpdateStmt(::google::protobuf::internal::ConstantInitialized);

  inline UpdateStmt(const UpdateStmt& from)
      : UpdateStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const UpdateStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const UpdateStmt* internal_default_instance() {
    return reinterpret_cast<const UpdateStmt*>(
               &_UpdateStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    129;

  friend void swap(UpdateStmt& a, UpdateStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(UpdateStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(UpdateStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  UpdateStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<UpdateStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const UpdateStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const UpdateStmt& from) {
    UpdateStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(UpdateStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.UpdateStmt";
  }
  protected:
  explicit UpdateStmt(::google::protobuf::Arena* arena);
  UpdateStmt(::google::protobuf::Arena* arena, const UpdateStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_target_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_target_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_target_list();
  public:
  const ::pg_query::Node& target_list(int index) const;
  ::pg_query::Node* add_target_list();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_from_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_from_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_from_clause();
  public:
  const ::pg_query::Node& from_clause(int index) const;
  ::pg_query::Node* add_from_clause();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_returning_list();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_returning_list() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_returning_list();
  public:
  const ::pg_query::Node& returning_list(int index) const;
  ::pg_query::Node* add_returning_list();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      returning_list() const;
  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // .pg_query.Node where_clause = 3 [json_name = "whereClause"];
  bool has_where_clause() const;
  void clear_where_clause() ;
  const ::pg_query::Node& where_clause() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause();
  ::pg_query::Node* mutable_where_clause();
  void set_allocated_where_clause(::pg_query::Node* value);
  void unsafe_arena_set_allocated_where_clause(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_where_clause();

  private:
  const ::pg_query::Node& _internal_where_clause() const;
  ::pg_query::Node* _internal_mutable_where_clause();

  public:
  // .pg_query.WithClause with_clause = 6 [json_name = "withClause"];
  bool has_with_clause() const;
  void clear_with_clause() ;
  const ::pg_query::WithClause& with_clause() const;
  PROTOBUF_NODISCARD ::pg_query::WithClause* release_with_clause();
  ::pg_query::WithClause* mutable_with_clause();
  void set_allocated_with_clause(::pg_query::WithClause* value);
  void unsafe_arena_set_allocated_with_clause(::pg_query::WithClause* value);
  ::pg_query::WithClause* unsafe_arena_release_with_clause();

  private:
  const ::pg_query::WithClause& _internal_with_clause() const;
  ::pg_query::WithClause* _internal_mutable_with_clause();

  public:
  // @@protoc_insertion_point(class_scope:pg_query.UpdateStmt)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 6,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > target_list_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > from_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > returning_list_;
    ::pg_query::RangeVar* relation_;
    ::pg_query::Node* where_clause_;
    ::pg_query::WithClause* with_clause_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class VacuumRelation final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.VacuumRelation) */ {
 public:
  inline VacuumRelation() : VacuumRelation(nullptr) {}
  ~VacuumRelation() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR VacuumRelation(::google::protobuf::internal::ConstantInitialized);

  inline VacuumRelation(const VacuumRelation& from)
      : VacuumRelation(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const VacuumRelation& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VacuumRelation* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  VacuumRelation* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<VacuumRelation>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const VacuumRelation& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const VacuumRelation& from) {
    VacuumRelation::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(VacuumRelation* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.VacuumRelation";
  }
  protected:
  explicit VacuumRelation(::google::protobuf::Arena* arena);
  VacuumRelation(::google::protobuf::Arena* arena, const VacuumRelation& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_va_cols();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_va_cols() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_va_cols();
  public:
  const ::pg_query::Node& va_cols(int index) const;
  ::pg_query::Node* add_va_cols();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      va_cols() const;
  // .pg_query.RangeVar relation = 1 [json_name = "relation"];
  bool has_relation() const;
  void clear_relation() ;
  const ::pg_query::RangeVar& relation() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation();
  ::pg_query::RangeVar* mutable_relation();
  void set_allocated_relation(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_relation();

  private:
  const ::pg_query::RangeVar& _internal_relation() const;
  ::pg_query::RangeVar* _internal_mutable_relation();

  public:
  // uint32 oid = 2 [json_name = "oid"];
  void clear_oid() ;
  ::uint32_t oid() const;
  void set_oid(::uint32_t value);

  private:
  ::uint32_t _internal_oid() const;
  void _internal_set_oid(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.VacuumRelation)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > va_cols_;
    ::pg_query::RangeVar* relation_;
    ::uint32_t oid_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class VacuumStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.VacuumStmt) */ {
 public:
  inline VacuumStmt() : VacuumStmt(nullptr) {}
  ~VacuumStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR VacuumStmt(::google::protobuf::internal::ConstantInitialized);

  inline VacuumStmt(const VacuumStmt& from)
      : VacuumStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const VacuumStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const VacuumStmt* internal_default_instance() {
    return reinterpret_cast<const VacuumStmt*>(
               &_VacuumStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    228;

  friend void swap(VacuumStmt& a, VacuumStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(VacuumStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VacuumStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  VacuumStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<VacuumStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const VacuumStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const VacuumStmt& from) {
    VacuumStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(VacuumStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.VacuumStmt";
  }
  protected:
  explicit VacuumStmt(::google::protobuf::Arena* arena);
  VacuumStmt(::google::protobuf::Arena* arena, const VacuumStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_rels();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_rels() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_rels();
  public:
  const ::pg_query::Node& rels(int index) const;
  ::pg_query::Node* add_rels();
  const ::google::protobuf::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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > rels_;
    bool is_vacuumcmd_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class Var final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.Var) */ {
 public:
  inline Var() : Var(nullptr) {}
  ~Var() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Var(::google::protobuf::internal::ConstantInitialized);

  inline Var(const Var& from)
      : Var(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Var& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Var* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Var* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Var>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Var& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const Var& from) {
    Var::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(Var* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.Var";
  }
  protected:
  explicit Var(::google::protobuf::Arena* arena);
  Var(::google::protobuf::Arena* arena, const Var& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kVarnullingrelsFieldNumber = 7,
    kXprFieldNumber = 1,
    kVarnoFieldNumber = 2,
    kVarattnoFieldNumber = 3,
    kVartypeFieldNumber = 4,
    kVartypmodFieldNumber = 5,
    kVarcollidFieldNumber = 6,
    kVarlevelsupFieldNumber = 8,
    kLocationFieldNumber = 9,
  };
  // repeated uint64 varnullingrels = 7 [json_name = "varnullingrels"];
  int varnullingrels_size() const;
  private:
  int _internal_varnullingrels_size() const;

  public:
  void clear_varnullingrels() ;
  ::uint64_t varnullingrels(int index) const;
  void set_varnullingrels(int index, ::uint64_t value);
  void add_varnullingrels(::uint64_t value);
  const ::google::protobuf::RepeatedField<::uint64_t>& varnullingrels() const;
  ::google::protobuf::RepeatedField<::uint64_t>* mutable_varnullingrels();

  private:
  const ::google::protobuf::RepeatedField<::uint64_t>& _internal_varnullingrels() const;
  ::google::protobuf::RepeatedField<::uint64_t>* _internal_mutable_varnullingrels();

  public:
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // int32 varno = 2 [json_name = "varno"];
  void clear_varno() ;
  ::int32_t varno() const;
  void set_varno(::int32_t value);

  private:
  ::int32_t _internal_varno() const;
  void _internal_set_varno(::int32_t value);

  public:
  // int32 varattno = 3 [json_name = "varattno"];
  void clear_varattno() ;
  ::int32_t varattno() const;
  void set_varattno(::int32_t value);

  private:
  ::int32_t _internal_varattno() const;
  void _internal_set_varattno(::int32_t value);

  public:
  // uint32 vartype = 4 [json_name = "vartype"];
  void clear_vartype() ;
  ::uint32_t vartype() const;
  void set_vartype(::uint32_t value);

  private:
  ::uint32_t _internal_vartype() const;
  void _internal_set_vartype(::uint32_t value);

  public:
  // int32 vartypmod = 5 [json_name = "vartypmod"];
  void clear_vartypmod() ;
  ::int32_t vartypmod() const;
  void set_vartypmod(::int32_t value);

  private:
  ::int32_t _internal_vartypmod() const;
  void _internal_set_vartypmod(::int32_t value);

  public:
  // uint32 varcollid = 6 [json_name = "varcollid"];
  void clear_varcollid() ;
  ::uint32_t varcollid() const;
  void set_varcollid(::uint32_t value);

  private:
  ::uint32_t _internal_varcollid() const;
  void _internal_set_varcollid(::uint32_t value);

  public:
  // uint32 varlevelsup = 8 [json_name = "varlevelsup"];
  void clear_varlevelsup() ;
  ::uint32_t varlevelsup() const;
  void set_varlevelsup(::uint32_t value);

  private:
  ::uint32_t _internal_varlevelsup() const;
  void _internal_set_varlevelsup(::uint32_t value);

  public:
  // int32 location = 9 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.Var)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 9, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedField<::uint64_t> varnullingrels_;
    mutable ::google::protobuf::internal::CachedSize _varnullingrels_cached_byte_size_;
    ::pg_query::Node* xpr_;
    ::int32_t varno_;
    ::int32_t varattno_;
    ::uint32_t vartype_;
    ::int32_t vartypmod_;
    ::uint32_t varcollid_;
    ::uint32_t varlevelsup_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class VariableSetStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.VariableSetStmt) */ {
 public:
  inline VariableSetStmt() : VariableSetStmt(nullptr) {}
  ~VariableSetStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR VariableSetStmt(::google::protobuf::internal::ConstantInitialized);

  inline VariableSetStmt(const VariableSetStmt& from)
      : VariableSetStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const VariableSetStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const VariableSetStmt* internal_default_instance() {
    return reinterpret_cast<const VariableSetStmt*>(
               &_VariableSetStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    147;

  friend void swap(VariableSetStmt& a, VariableSetStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(VariableSetStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VariableSetStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  VariableSetStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<VariableSetStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const VariableSetStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const VariableSetStmt& from) {
    VariableSetStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(VariableSetStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.VariableSetStmt";
  }
  protected:
  explicit VariableSetStmt(::google::protobuf::Arena* arena);
  VariableSetStmt(::google::protobuf::Arena* arena, const VariableSetStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // string name = 2 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 1,
      37, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    int kind_;
    bool is_local_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ViewStmt final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ViewStmt) */ {
 public:
  inline ViewStmt() : ViewStmt(nullptr) {}
  ~ViewStmt() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ViewStmt(::google::protobuf::internal::ConstantInitialized);

  inline ViewStmt(const ViewStmt& from)
      : ViewStmt(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ViewStmt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ViewStmt* internal_default_instance() {
    return reinterpret_cast<const ViewStmt*>(
               &_ViewStmt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    219;

  friend void swap(ViewStmt& a, ViewStmt& b) {
    a.Swap(&b);
  }
  inline void Swap(ViewStmt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ViewStmt* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ViewStmt* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ViewStmt>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ViewStmt& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ViewStmt& from) {
    ViewStmt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ViewStmt* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ViewStmt";
  }
  protected:
  explicit ViewStmt(::google::protobuf::Arena* arena);
  ViewStmt(::google::protobuf::Arena* arena, const ViewStmt& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_aliases();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_aliases() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_aliases();
  public:
  const ::pg_query::Node& aliases(int index) const;
  ::pg_query::Node* add_aliases();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_options();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_options() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_options();
  public:
  const ::pg_query::Node& options(int index) const;
  ::pg_query::Node* add_options();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      options() const;
  // .pg_query.RangeVar view = 1 [json_name = "view"];
  bool has_view() const;
  void clear_view() ;
  const ::pg_query::RangeVar& view() const;
  PROTOBUF_NODISCARD ::pg_query::RangeVar* release_view();
  ::pg_query::RangeVar* mutable_view();
  void set_allocated_view(::pg_query::RangeVar* value);
  void unsafe_arena_set_allocated_view(::pg_query::RangeVar* value);
  ::pg_query::RangeVar* unsafe_arena_release_view();

  private:
  const ::pg_query::RangeVar& _internal_view() const;
  ::pg_query::RangeVar* _internal_mutable_view();

  public:
  // .pg_query.Node query = 3 [json_name = "query"];
  bool has_query() const;
  void clear_query() ;
  const ::pg_query::Node& query() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_query();
  ::pg_query::Node* mutable_query();
  void set_allocated_query(::pg_query::Node* value);
  void unsafe_arena_set_allocated_query(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_query();

  private:
  const ::pg_query::Node& _internal_query() const;
  ::pg_query::Node* _internal_mutable_query();

  public:
  // 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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 4,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > aliases_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > options_;
    ::pg_query::RangeVar* view_;
    ::pg_query::Node* query_;
    bool replace_;
    int with_check_option_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class WindowClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.WindowClause) */ {
 public:
  inline WindowClause() : WindowClause(nullptr) {}
  ~WindowClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR WindowClause(::google::protobuf::internal::ConstantInitialized);

  inline WindowClause(const WindowClause& from)
      : WindowClause(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const WindowClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const WindowClause* internal_default_instance() {
    return reinterpret_cast<const WindowClause*>(
               &_WindowClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    107;

  friend void swap(WindowClause& a, WindowClause& b) {
    a.Swap(&b);
  }
  inline void Swap(WindowClause* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(WindowClause* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  WindowClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<WindowClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const WindowClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const WindowClause& from) {
    WindowClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(WindowClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.WindowClause";
  }
  protected:
  explicit WindowClause(::google::protobuf::Arena* arena);
  WindowClause(::google::protobuf::Arena* arena, const WindowClause& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPartitionClauseFieldNumber = 3,
    kOrderClauseFieldNumber = 4,
    kRunConditionFieldNumber = 8,
    kNameFieldNumber = 1,
    kRefnameFieldNumber = 2,
    kStartOffsetFieldNumber = 6,
    kEndOffsetFieldNumber = 7,
    kFrameOptionsFieldNumber = 5,
    kStartInRangeFuncFieldNumber = 9,
    kEndInRangeFuncFieldNumber = 10,
    kInRangeCollFieldNumber = 11,
    kInRangeAscFieldNumber = 12,
    kInRangeNullsFirstFieldNumber = 13,
    kCopiedOrderFieldNumber = 15,
    kWinrefFieldNumber = 14,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_partition_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_partition_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_partition_clause();
  public:
  const ::pg_query::Node& partition_clause(int index) const;
  ::pg_query::Node* add_partition_clause();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_order_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_order_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_order_clause();
  public:
  const ::pg_query::Node& order_clause(int index) const;
  ::pg_query::Node* add_order_clause();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      order_clause() const;
  // repeated .pg_query.Node run_condition = 8 [json_name = "runCondition"];
  int run_condition_size() const;
  private:
  int _internal_run_condition_size() const;

  public:
  void clear_run_condition() ;
  ::pg_query::Node* mutable_run_condition(int index);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_run_condition();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_run_condition() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_run_condition();
  public:
  const ::pg_query::Node& run_condition(int index) const;
  ::pg_query::Node* add_run_condition();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      run_condition() const;
  // string name = 1 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // string refname = 2 [json_name = "refname"];
  void clear_refname() ;
  const std::string& refname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_refname(Arg_&& arg, Args_... args);
  std::string* mutable_refname();
  PROTOBUF_NODISCARD std::string* release_refname();
  void set_allocated_refname(std::string* value);

  private:
  const std::string& _internal_refname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_start_offset() ;
  const ::pg_query::Node& start_offset() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_start_offset();
  ::pg_query::Node* mutable_start_offset();
  void set_allocated_start_offset(::pg_query::Node* value);
  void unsafe_arena_set_allocated_start_offset(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_start_offset();

  private:
  const ::pg_query::Node& _internal_start_offset() const;
  ::pg_query::Node* _internal_mutable_start_offset();

  public:
  // .pg_query.Node end_offset = 7 [json_name = "endOffset"];
  bool has_end_offset() const;
  void clear_end_offset() ;
  const ::pg_query::Node& end_offset() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_end_offset();
  ::pg_query::Node* mutable_end_offset();
  void set_allocated_end_offset(::pg_query::Node* value);
  void unsafe_arena_set_allocated_end_offset(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_end_offset();

  private:
  const ::pg_query::Node& _internal_end_offset() const;
  ::pg_query::Node* _internal_mutable_end_offset();

  public:
  // int32 frame_options = 5 [json_name = "frameOptions"];
  void clear_frame_options() ;
  ::int32_t frame_options() const;
  void set_frame_options(::int32_t value);

  private:
  ::int32_t _internal_frame_options() const;
  void _internal_set_frame_options(::int32_t value);

  public:
  // uint32 start_in_range_func = 9 [json_name = "startInRangeFunc"];
  void clear_start_in_range_func() ;
  ::uint32_t start_in_range_func() const;
  void set_start_in_range_func(::uint32_t value);

  private:
  ::uint32_t _internal_start_in_range_func() const;
  void _internal_set_start_in_range_func(::uint32_t value);

  public:
  // uint32 end_in_range_func = 10 [json_name = "endInRangeFunc"];
  void clear_end_in_range_func() ;
  ::uint32_t end_in_range_func() const;
  void set_end_in_range_func(::uint32_t value);

  private:
  ::uint32_t _internal_end_in_range_func() const;
  void _internal_set_end_in_range_func(::uint32_t value);

  public:
  // uint32 in_range_coll = 11 [json_name = "inRangeColl"];
  void clear_in_range_coll() ;
  ::uint32_t in_range_coll() const;
  void set_in_range_coll(::uint32_t value);

  private:
  ::uint32_t _internal_in_range_coll() const;
  void _internal_set_in_range_coll(::uint32_t value);

  public:
  // bool in_range_asc = 12 [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 = 13 [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 = 15 [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 = 14 [json_name = "winref"];
  void clear_winref() ;
  ::uint32_t winref() const;
  void set_winref(::uint32_t value);

  private:
  ::uint32_t _internal_winref() const;
  void _internal_set_winref(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.WindowClause)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 15, 5,
      49, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > partition_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > order_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > run_condition_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr refname_;
    ::pg_query::Node* start_offset_;
    ::pg_query::Node* end_offset_;
    ::int32_t frame_options_;
    ::uint32_t start_in_range_func_;
    ::uint32_t end_in_range_func_;
    ::uint32_t in_range_coll_;
    bool in_range_asc_;
    bool in_range_nulls_first_;
    bool copied_order_;
    ::uint32_t winref_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class WindowDef final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.WindowDef) */ {
 public:
  inline WindowDef() : WindowDef(nullptr) {}
  ~WindowDef() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR WindowDef(::google::protobuf::internal::ConstantInitialized);

  inline WindowDef(const WindowDef& from)
      : WindowDef(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const WindowDef& default_instance() {
    return *internal_default_instance();
  }
  static inline const WindowDef* internal_default_instance() {
    return reinterpret_cast<const WindowDef*>(
               &_WindowDef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    83;

  friend void swap(WindowDef& a, WindowDef& b) {
    a.Swap(&b);
  }
  inline void Swap(WindowDef* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(WindowDef* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  WindowDef* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<WindowDef>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const WindowDef& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const WindowDef& from) {
    WindowDef::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(WindowDef* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.WindowDef";
  }
  protected:
  explicit WindowDef(::google::protobuf::Arena* arena);
  WindowDef(::google::protobuf::Arena* arena, const WindowDef& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_partition_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_partition_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_partition_clause();
  public:
  const ::pg_query::Node& partition_clause(int index) const;
  ::pg_query::Node* add_partition_clause();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_order_clause();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_order_clause() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_order_clause();
  public:
  const ::pg_query::Node& order_clause(int index) const;
  ::pg_query::Node* add_order_clause();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      order_clause() const;
  // string name = 1 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // string refname = 2 [json_name = "refname"];
  void clear_refname() ;
  const std::string& refname() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_refname(Arg_&& arg, Args_... args);
  std::string* mutable_refname();
  PROTOBUF_NODISCARD std::string* release_refname();
  void set_allocated_refname(std::string* value);

  private:
  const std::string& _internal_refname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_start_offset() ;
  const ::pg_query::Node& start_offset() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_start_offset();
  ::pg_query::Node* mutable_start_offset();
  void set_allocated_start_offset(::pg_query::Node* value);
  void unsafe_arena_set_allocated_start_offset(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_start_offset();

  private:
  const ::pg_query::Node& _internal_start_offset() const;
  ::pg_query::Node* _internal_mutable_start_offset();

  public:
  // .pg_query.Node end_offset = 7 [json_name = "endOffset"];
  bool has_end_offset() const;
  void clear_end_offset() ;
  const ::pg_query::Node& end_offset() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_end_offset();
  ::pg_query::Node* mutable_end_offset();
  void set_allocated_end_offset(::pg_query::Node* value);
  void unsafe_arena_set_allocated_end_offset(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_end_offset();

  private:
  const ::pg_query::Node& _internal_end_offset() const;
  ::pg_query::Node* _internal_mutable_end_offset();

  public:
  // int32 frame_options = 5 [json_name = "frameOptions"];
  void clear_frame_options() ;
  ::int32_t frame_options() const;
  void set_frame_options(::int32_t value);

  private:
  ::int32_t _internal_frame_options() const;
  void _internal_set_frame_options(::int32_t value);

  public:
  // int32 location = 8 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.WindowDef)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 8, 4,
      46, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > partition_clause_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > order_clause_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr refname_;
    ::pg_query::Node* start_offset_;
    ::pg_query::Node* end_offset_;
    ::int32_t frame_options_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class WindowFunc final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.WindowFunc) */ {
 public:
  inline WindowFunc() : WindowFunc(nullptr) {}
  ~WindowFunc() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR WindowFunc(::google::protobuf::internal::ConstantInitialized);

  inline WindowFunc(const WindowFunc& from)
      : WindowFunc(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const WindowFunc& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(WindowFunc* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  WindowFunc* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<WindowFunc>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const WindowFunc& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const WindowFunc& from) {
    WindowFunc::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(WindowFunc* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.WindowFunc";
  }
  protected:
  explicit WindowFunc(::google::protobuf::Arena* arena);
  WindowFunc(::google::protobuf::Arena* arena, const WindowFunc& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .pg_query.Node aggfilter = 7 [json_name = "aggfilter"];
  bool has_aggfilter() const;
  void clear_aggfilter() ;
  const ::pg_query::Node& aggfilter() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_aggfilter();
  ::pg_query::Node* mutable_aggfilter();
  void set_allocated_aggfilter(::pg_query::Node* value);
  void unsafe_arena_set_allocated_aggfilter(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_aggfilter();

  private:
  const ::pg_query::Node& _internal_aggfilter() const;
  ::pg_query::Node* _internal_mutable_aggfilter();

  public:
  // uint32 winfnoid = 2 [json_name = "winfnoid"];
  void clear_winfnoid() ;
  ::uint32_t winfnoid() const;
  void set_winfnoid(::uint32_t value);

  private:
  ::uint32_t _internal_winfnoid() const;
  void _internal_set_winfnoid(::uint32_t value);

  public:
  // uint32 wintype = 3 [json_name = "wintype"];
  void clear_wintype() ;
  ::uint32_t wintype() const;
  void set_wintype(::uint32_t value);

  private:
  ::uint32_t _internal_wintype() const;
  void _internal_set_wintype(::uint32_t value);

  public:
  // uint32 wincollid = 4 [json_name = "wincollid"];
  void clear_wincollid() ;
  ::uint32_t wincollid() const;
  void set_wincollid(::uint32_t value);

  private:
  ::uint32_t _internal_wincollid() const;
  void _internal_set_wincollid(::uint32_t value);

  public:
  // uint32 inputcollid = 5 [json_name = "inputcollid"];
  void clear_inputcollid() ;
  ::uint32_t inputcollid() const;
  void set_inputcollid(::uint32_t value);

  private:
  ::uint32_t _internal_inputcollid() const;
  void _internal_set_inputcollid(::uint32_t value);

  public:
  // uint32 winref = 8 [json_name = "winref"];
  void clear_winref() ;
  ::uint32_t winref() const;
  void set_winref(::uint32_t value);

  private:
  ::uint32_t _internal_winref() const;
  void _internal_set_winref(::uint32_t 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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.WindowFunc)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 11, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::pg_query::Node* xpr_;
    ::pg_query::Node* aggfilter_;
    ::uint32_t winfnoid_;
    ::uint32_t wintype_;
    ::uint32_t wincollid_;
    ::uint32_t inputcollid_;
    ::uint32_t winref_;
    bool winstar_;
    bool winagg_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class WithCheckOption final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.WithCheckOption) */ {
 public:
  inline WithCheckOption() : WithCheckOption(nullptr) {}
  ~WithCheckOption() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR WithCheckOption(::google::protobuf::internal::ConstantInitialized);

  inline WithCheckOption(const WithCheckOption& from)
      : WithCheckOption(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const WithCheckOption& default_instance() {
    return *internal_default_instance();
  }
  static inline const WithCheckOption* internal_default_instance() {
    return reinterpret_cast<const WithCheckOption*>(
               &_WithCheckOption_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    104;

  friend void swap(WithCheckOption& a, WithCheckOption& b) {
    a.Swap(&b);
  }
  inline void Swap(WithCheckOption* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(WithCheckOption* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  WithCheckOption* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<WithCheckOption>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const WithCheckOption& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const WithCheckOption& from) {
    WithCheckOption::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(WithCheckOption* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.WithCheckOption";
  }
  protected:
  explicit WithCheckOption(::google::protobuf::Arena* arena);
  WithCheckOption(::google::protobuf::Arena* arena, const WithCheckOption& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_relname(Arg_&& arg, Args_... args);
  std::string* mutable_relname();
  PROTOBUF_NODISCARD std::string* release_relname();
  void set_allocated_relname(std::string* value);

  private:
  const std::string& _internal_relname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_polname(Arg_&& arg, Args_... args);
  std::string* mutable_polname();
  PROTOBUF_NODISCARD std::string* release_polname();
  void set_allocated_polname(std::string* value);

  private:
  const std::string& _internal_polname() const;
  inline PROTOBUF_ALWAYS_INLINE 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;
  void clear_qual() ;
  const ::pg_query::Node& qual() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_qual();
  ::pg_query::Node* mutable_qual();
  void set_allocated_qual(::pg_query::Node* value);
  void unsafe_arena_set_allocated_qual(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_qual();

  private:
  const ::pg_query::Node& _internal_qual() const;
  ::pg_query::Node* _internal_mutable_qual();

  public:
  // .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;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 1,
      47, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr relname_;
    ::google::protobuf::internal::ArenaStringPtr polname_;
    ::pg_query::Node* qual_;
    int kind_;
    bool cascaded_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class WithClause final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.WithClause) */ {
 public:
  inline WithClause() : WithClause(nullptr) {}
  ~WithClause() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR WithClause(::google::protobuf::internal::ConstantInitialized);

  inline WithClause(const WithClause& from)
      : WithClause(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const WithClause& default_instance() {
    return *internal_default_instance();
  }
  static inline const WithClause* internal_default_instance() {
    return reinterpret_cast<const WithClause*>(
               &_WithClause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    109;

  friend void swap(WithClause& a, WithClause& b) {
    a.Swap(&b);
  }
  inline void Swap(WithClause* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(WithClause* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  WithClause* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<WithClause>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const WithClause& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const WithClause& from) {
    WithClause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(WithClause* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.WithClause";
  }
  protected:
  explicit WithClause(::google::protobuf::Arena* arena);
  WithClause(::google::protobuf::Arena* arena, const WithClause& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_ctes();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_ctes() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_ctes();
  public:
  const ::pg_query::Node& ctes(int index) const;
  ::pg_query::Node* add_ctes();
  const ::google::protobuf::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() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.WithClause)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > ctes_;
    bool recursive_;
    ::int32_t location_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class XmlExpr final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.XmlExpr) */ {
 public:
  inline XmlExpr() : XmlExpr(nullptr) {}
  ~XmlExpr() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR XmlExpr(::google::protobuf::internal::ConstantInitialized);

  inline XmlExpr(const XmlExpr& from)
      : XmlExpr(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const XmlExpr& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(XmlExpr* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  XmlExpr* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<XmlExpr>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const XmlExpr& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const XmlExpr& from) {
    XmlExpr::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(XmlExpr* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.XmlExpr";
  }
  protected:
  explicit XmlExpr(::google::protobuf::Arena* arena);
  XmlExpr(::google::protobuf::Arena* arena, const XmlExpr& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNamedArgsFieldNumber = 4,
    kArgNamesFieldNumber = 5,
    kArgsFieldNumber = 6,
    kNameFieldNumber = 3,
    kXprFieldNumber = 1,
    kOpFieldNumber = 2,
    kXmloptionFieldNumber = 7,
    kIndentFieldNumber = 8,
    kTypeFieldNumber = 9,
    kTypmodFieldNumber = 10,
    kLocationFieldNumber = 11,
  };
  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_named_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_named_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_named_args();
  public:
  const ::pg_query::Node& named_args(int index) const;
  ::pg_query::Node* add_named_args();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_arg_names();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_arg_names() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_arg_names();
  public:
  const ::pg_query::Node& arg_names(int index) const;
  ::pg_query::Node* add_arg_names();
  const ::google::protobuf::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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::Node >*
      mutable_args();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& _internal_args() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::Node>* _internal_mutable_args();
  public:
  const ::pg_query::Node& args(int index) const;
  ::pg_query::Node* add_args();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::Node >&
      args() const;
  // string name = 3 [json_name = "name"];
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .pg_query.Node xpr = 1 [json_name = "xpr"];
  bool has_xpr() const;
  void clear_xpr() ;
  const ::pg_query::Node& xpr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_xpr();
  ::pg_query::Node* mutable_xpr();
  void set_allocated_xpr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_xpr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_xpr();

  private:
  const ::pg_query::Node& _internal_xpr() const;
  ::pg_query::Node* _internal_mutable_xpr();

  public:
  // .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:
  // bool indent = 8 [json_name = "indent"];
  void clear_indent() ;
  bool indent() const;
  void set_indent(bool value);

  private:
  bool _internal_indent() const;
  void _internal_set_indent(bool value);

  public:
  // uint32 type = 9 [json_name = "type"];
  void clear_type() ;
  ::uint32_t type() const;
  void set_type(::uint32_t value);

  private:
  ::uint32_t _internal_type() const;
  void _internal_set_type(::uint32_t value);

  public:
  // int32 typmod = 10 [json_name = "typmod"];
  void clear_typmod() ;
  ::int32_t typmod() const;
  void set_typmod(::int32_t value);

  private:
  ::int32_t _internal_typmod() const;
  void _internal_set_typmod(::int32_t value);

  public:
  // int32 location = 11 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.XmlExpr)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 11, 4,
      37, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > named_args_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > arg_names_;
    ::google::protobuf::RepeatedPtrField< ::pg_query::Node > args_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::pg_query::Node* xpr_;
    int op_;
    int xmloption_;
    bool indent_;
    ::uint32_t type_;
    ::int32_t typmod_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class XmlSerialize final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.XmlSerialize) */ {
 public:
  inline XmlSerialize() : XmlSerialize(nullptr) {}
  ~XmlSerialize() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR XmlSerialize(::google::protobuf::internal::ConstantInitialized);

  inline XmlSerialize(const XmlSerialize& from)
      : XmlSerialize(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const XmlSerialize& default_instance() {
    return *internal_default_instance();
  }
  static inline const XmlSerialize* internal_default_instance() {
    return reinterpret_cast<const XmlSerialize*>(
               &_XmlSerialize_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    94;

  friend void swap(XmlSerialize& a, XmlSerialize& b) {
    a.Swap(&b);
  }
  inline void Swap(XmlSerialize* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(XmlSerialize* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  XmlSerialize* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<XmlSerialize>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const XmlSerialize& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const XmlSerialize& from) {
    XmlSerialize::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(XmlSerialize* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.XmlSerialize";
  }
  protected:
  explicit XmlSerialize(::google::protobuf::Arena* arena);
  XmlSerialize(::google::protobuf::Arena* arena, const XmlSerialize& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kExprFieldNumber = 2,
    kTypeNameFieldNumber = 3,
    kXmloptionFieldNumber = 1,
    kIndentFieldNumber = 4,
    kLocationFieldNumber = 5,
  };
  // .pg_query.Node expr = 2 [json_name = "expr"];
  bool has_expr() const;
  void clear_expr() ;
  const ::pg_query::Node& expr() const;
  PROTOBUF_NODISCARD ::pg_query::Node* release_expr();
  ::pg_query::Node* mutable_expr();
  void set_allocated_expr(::pg_query::Node* value);
  void unsafe_arena_set_allocated_expr(::pg_query::Node* value);
  ::pg_query::Node* unsafe_arena_release_expr();

  private:
  const ::pg_query::Node& _internal_expr() const;
  ::pg_query::Node* _internal_mutable_expr();

  public:
  // .pg_query.TypeName type_name = 3 [json_name = "typeName"];
  bool has_type_name() const;
  void clear_type_name() ;
  const ::pg_query::TypeName& type_name() const;
  PROTOBUF_NODISCARD ::pg_query::TypeName* release_type_name();
  ::pg_query::TypeName* mutable_type_name();
  void set_allocated_type_name(::pg_query::TypeName* value);
  void unsafe_arena_set_allocated_type_name(::pg_query::TypeName* value);
  ::pg_query::TypeName* unsafe_arena_release_type_name();

  private:
  const ::pg_query::TypeName& _internal_type_name() const;
  ::pg_query::TypeName* _internal_mutable_type_name();

  public:
  // .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:
  // bool indent = 4 [json_name = "indent"];
  void clear_indent() ;
  bool indent() const;
  void set_indent(bool value);

  private:
  bool _internal_indent() const;
  void _internal_set_indent(bool value);

  public:
  // int32 location = 5 [json_name = "location"];
  void clear_location() ;
  ::int32_t location() const;
  void set_location(::int32_t value);

  private:
  ::int32_t _internal_location() const;
  void _internal_set_location(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.XmlSerialize)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::pg_query::Node* expr_;
    ::pg_query::TypeName* type_name_;
    int xmloption_;
    bool indent_;
    ::int32_t location_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto;
};// -------------------------------------------------------------------

class ParseResult final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pg_query.ParseResult) */ {
 public:
  inline ParseResult() : ParseResult(nullptr) {}
  ~ParseResult() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ParseResult(::google::protobuf::internal::ConstantInitialized);

  inline ParseResult(const ParseResult& from)
      : ParseResult(nullptr, 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 (this == &from) return *this;
    if (GetArena() == from.GetArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ParseResult& default_instance() {
    return *internal_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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ParseResult* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ParseResult* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ParseResult>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ParseResult& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const ParseResult& from) {
    ParseResult::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ParseResult* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "pg_query.ParseResult";
  }
  protected:
  explicit ParseResult(::google::protobuf::Arena* arena);
  ParseResult(::google::protobuf::Arena* arena, const ParseResult& from);
  public:

  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;

  ::google::protobuf::Metadata GetMetadata() const final;

  // 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);
  ::google::protobuf::RepeatedPtrField< ::pg_query::RawStmt >*
      mutable_stmts();
  private:
  const ::google::protobuf::RepeatedPtrField<::pg_query::RawStmt>& _internal_stmts() const;
  ::google::protobuf::RepeatedPtrField<::pg_query::RawStmt>* _internal_mutable_stmts();
  public:
  const ::pg_query::RawStmt& stmts(int index) const;
  ::pg_query::RawStmt* add_stmts();
  const ::google::protobuf::RepeatedPtrField< ::pg_query::RawStmt >&
      stmts() const;
  // int32 version = 1;
  void clear_version() ;
  ::int32_t version() const;
  void set_version(::int32_t value);

  private:
  ::int32_t _internal_version() const;
  void _internal_set_version(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:pg_query.ParseResult)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::pg_query::RawStmt > stmts_;
    ::int32_t version_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.version_ = 0;
}
inline ::int32_t ParseResult::version() const {
  // @@protoc_insertion_point(field_get:pg_query.ParseResult.version)
  return _internal_version();
}
inline void ParseResult::set_version(::int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:pg_query.ParseResult.version)
}
inline ::int32_t ParseResult::_internal_version() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.version_;
}
inline void ParseResult::_internal_set_version(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.version_ = value;
}

// repeated .pg_query.RawStmt stmts = 2;
inline int ParseResult::_internal_stmts_size() const {
  return _internal_stmts().size();
}
inline int ParseResult::stmts_size() const {
  return _internal_stmts_size();
}
inline void ParseResult::clear_stmts() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stmts_.Clear();
}
inline ::pg_query::RawStmt* ParseResult::mutable_stmts(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ParseResult.stmts)
  return _internal_mutable_stmts()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::RawStmt>* ParseResult::mutable_stmts()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ParseResult.stmts)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_stmts();
}
inline const ::pg_query::RawStmt& ParseResult::stmts(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ParseResult.stmts)
  return _internal_stmts().Get(index);
}
inline ::pg_query::RawStmt* ParseResult::add_stmts() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::RawStmt* _add = _internal_mutable_stmts()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ParseResult.stmts)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::RawStmt>& ParseResult::stmts() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ParseResult.stmts)
  return _internal_stmts();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::RawStmt>&
ParseResult::_internal_stmts() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.stmts_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::RawStmt>*
ParseResult::_internal_mutable_stmts() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.stmts_;
}

// -------------------------------------------------------------------

// ScanResult

// int32 version = 1;
inline void ScanResult::clear_version() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.version_ = 0;
}
inline ::int32_t ScanResult::version() const {
  // @@protoc_insertion_point(field_get:pg_query.ScanResult.version)
  return _internal_version();
}
inline void ScanResult::set_version(::int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:pg_query.ScanResult.version)
}
inline ::int32_t ScanResult::_internal_version() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.version_;
}
inline void ScanResult::_internal_set_version(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.version_ = value;
}

// repeated .pg_query.ScanToken tokens = 2;
inline int ScanResult::_internal_tokens_size() const {
  return _internal_tokens().size();
}
inline int ScanResult::tokens_size() const {
  return _internal_tokens_size();
}
inline void ScanResult::clear_tokens() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tokens_.Clear();
}
inline ::pg_query::ScanToken* ScanResult::mutable_tokens(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ScanResult.tokens)
  return _internal_mutable_tokens()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::ScanToken>* ScanResult::mutable_tokens()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ScanResult.tokens)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_tokens();
}
inline const ::pg_query::ScanToken& ScanResult::tokens(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ScanResult.tokens)
  return _internal_tokens().Get(index);
}
inline ::pg_query::ScanToken* ScanResult::add_tokens() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::ScanToken* _add = _internal_mutable_tokens()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ScanResult.tokens)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::ScanToken>& ScanResult::tokens() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ScanResult.tokens)
  return _internal_tokens();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::ScanToken>&
ScanResult::_internal_tokens() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.tokens_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::ScanToken>*
ScanResult::_internal_mutable_tokens() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.tokens_;
}

// -------------------------------------------------------------------

// Node

// .pg_query.Alias alias = 1 [json_name = "Alias"];
inline bool Node::has_alias() const {
  return node_case() == kAlias;
}
inline bool Node::_internal_has_alias() const {
  return node_case() == kAlias;
}
inline void Node::set_has_alias() {
  _impl_._oneof_case_[0] = kAlias;
}
inline void Node::clear_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlias) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.alias_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Alias* Node::release_alias() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alias)
  if (node_case() == kAlias) {
    clear_has_node();
    auto* temp = _impl_.node_.alias_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alias_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Alias& Node::_internal_alias() const {
  return node_case() == kAlias ? *_impl_.node_.alias_ : reinterpret_cast<::pg_query::Alias&>(::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& Node::alias() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlias) {
    clear_has_node();
    auto* temp = _impl_.node_.alias_;
    _impl_.node_.alias_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alias(::pg_query::Alias* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alias();
    _impl_.node_.alias_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alias)
}
inline ::pg_query::Alias* Node::_internal_mutable_alias() {
  if (node_case() != kAlias) {
    clear_node();
    set_has_alias();
    _impl_.node_.alias_ = CreateMaybeMessage<::pg_query::Alias>(GetArena());
  }
  return _impl_.node_.alias_;
}
inline ::pg_query::Alias* Node::mutable_alias() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Alias* _msg = _internal_mutable_alias();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alias)
  return _msg;
}

// .pg_query.RangeVar range_var = 2 [json_name = "RangeVar"];
inline bool Node::has_range_var() const {
  return node_case() == kRangeVar;
}
inline bool Node::_internal_has_range_var() const {
  return node_case() == kRangeVar;
}
inline void Node::set_has_range_var() {
  _impl_._oneof_case_[0] = kRangeVar;
}
inline void Node::clear_range_var() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRangeVar) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRangeVar) {
    clear_has_node();
    auto* temp = _impl_.node_.range_var_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.range_var_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeVar& Node::_internal_range_var() const {
  return node_case() == kRangeVar ? *_impl_.node_.range_var_ : reinterpret_cast<::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& Node::range_var() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRangeVar) {
    clear_has_node();
    auto* temp = _impl_.node_.range_var_;
    _impl_.node_.range_var_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_var(::pg_query::RangeVar* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_range_var();
    _impl_.node_.range_var_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_var)
}
inline ::pg_query::RangeVar* Node::_internal_mutable_range_var() {
  if (node_case() != kRangeVar) {
    clear_node();
    set_has_range_var();
    _impl_.node_.range_var_ = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
  }
  return _impl_.node_.range_var_;
}
inline ::pg_query::RangeVar* Node::mutable_range_var() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_range_var();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_var)
  return _msg;
}

// .pg_query.TableFunc table_func = 3 [json_name = "TableFunc"];
inline bool Node::has_table_func() const {
  return node_case() == kTableFunc;
}
inline bool Node::_internal_has_table_func() const {
  return node_case() == kTableFunc;
}
inline void Node::set_has_table_func() {
  _impl_._oneof_case_[0] = kTableFunc;
}
inline void Node::clear_table_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kTableFunc) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kTableFunc) {
    clear_has_node();
    auto* temp = _impl_.node_.table_func_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.table_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TableFunc& Node::_internal_table_func() const {
  return node_case() == kTableFunc ? *_impl_.node_.table_func_ : reinterpret_cast<::pg_query::TableFunc&>(::pg_query::_TableFunc_default_instance_);
}
inline const ::pg_query::TableFunc& Node::table_func() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kTableFunc) {
    clear_has_node();
    auto* temp = _impl_.node_.table_func_;
    _impl_.node_.table_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_table_func(::pg_query::TableFunc* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_table_func();
    _impl_.node_.table_func_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.table_func)
}
inline ::pg_query::TableFunc* Node::_internal_mutable_table_func() {
  if (node_case() != kTableFunc) {
    clear_node();
    set_has_table_func();
    _impl_.node_.table_func_ = CreateMaybeMessage<::pg_query::TableFunc>(GetArena());
  }
  return _impl_.node_.table_func_;
}
inline ::pg_query::TableFunc* Node::mutable_table_func() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TableFunc* _msg = _internal_mutable_table_func();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.table_func)
  return _msg;
}

// .pg_query.IntoClause into_clause = 4 [json_name = "IntoClause"];
inline bool Node::has_into_clause() const {
  return node_case() == kIntoClause;
}
inline bool Node::_internal_has_into_clause() const {
  return node_case() == kIntoClause;
}
inline void Node::set_has_into_clause() {
  _impl_._oneof_case_[0] = kIntoClause;
}
inline void Node::clear_into_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kIntoClause) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kIntoClause) {
    clear_has_node();
    auto* temp = _impl_.node_.into_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.into_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::IntoClause& Node::_internal_into_clause() const {
  return node_case() == kIntoClause ? *_impl_.node_.into_clause_ : reinterpret_cast<::pg_query::IntoClause&>(::pg_query::_IntoClause_default_instance_);
}
inline const ::pg_query::IntoClause& Node::into_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kIntoClause) {
    clear_has_node();
    auto* temp = _impl_.node_.into_clause_;
    _impl_.node_.into_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_into_clause(::pg_query::IntoClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_into_clause();
    _impl_.node_.into_clause_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.into_clause)
}
inline ::pg_query::IntoClause* Node::_internal_mutable_into_clause() {
  if (node_case() != kIntoClause) {
    clear_node();
    set_has_into_clause();
    _impl_.node_.into_clause_ = CreateMaybeMessage<::pg_query::IntoClause>(GetArena());
  }
  return _impl_.node_.into_clause_;
}
inline ::pg_query::IntoClause* Node::mutable_into_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::IntoClause* _msg = _internal_mutable_into_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.into_clause)
  return _msg;
}

// .pg_query.Var var = 5 [json_name = "Var"];
inline bool Node::has_var() const {
  return node_case() == kVar;
}
inline bool Node::_internal_has_var() const {
  return node_case() == kVar;
}
inline void Node::set_has_var() {
  _impl_._oneof_case_[0] = kVar;
}
inline void Node::clear_var() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kVar) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.var_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Var* Node::release_var() {
  // @@protoc_insertion_point(field_release:pg_query.Node.var)
  if (node_case() == kVar) {
    clear_has_node();
    auto* temp = _impl_.node_.var_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.var_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Var& Node::_internal_var() const {
  return node_case() == kVar ? *_impl_.node_.var_ : reinterpret_cast<::pg_query::Var&>(::pg_query::_Var_default_instance_);
}
inline const ::pg_query::Var& Node::var() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kVar) {
    clear_has_node();
    auto* temp = _impl_.node_.var_;
    _impl_.node_.var_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_var(::pg_query::Var* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_var();
    _impl_.node_.var_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.var)
}
inline ::pg_query::Var* Node::_internal_mutable_var() {
  if (node_case() != kVar) {
    clear_node();
    set_has_var();
    _impl_.node_.var_ = CreateMaybeMessage<::pg_query::Var>(GetArena());
  }
  return _impl_.node_.var_;
}
inline ::pg_query::Var* Node::mutable_var() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Var* _msg = _internal_mutable_var();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.var)
  return _msg;
}

// .pg_query.Param param = 6 [json_name = "Param"];
inline bool Node::has_param() const {
  return node_case() == kParam;
}
inline bool Node::_internal_has_param() const {
  return node_case() == kParam;
}
inline void Node::set_has_param() {
  _impl_._oneof_case_[0] = kParam;
}
inline void Node::clear_param() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kParam) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.param_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Param* Node::release_param() {
  // @@protoc_insertion_point(field_release:pg_query.Node.param)
  if (node_case() == kParam) {
    clear_has_node();
    auto* temp = _impl_.node_.param_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.param_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Param& Node::_internal_param() const {
  return node_case() == kParam ? *_impl_.node_.param_ : reinterpret_cast<::pg_query::Param&>(::pg_query::_Param_default_instance_);
}
inline const ::pg_query::Param& Node::param() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kParam) {
    clear_has_node();
    auto* temp = _impl_.node_.param_;
    _impl_.node_.param_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_param(::pg_query::Param* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_param();
    _impl_.node_.param_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.param)
}
inline ::pg_query::Param* Node::_internal_mutable_param() {
  if (node_case() != kParam) {
    clear_node();
    set_has_param();
    _impl_.node_.param_ = CreateMaybeMessage<::pg_query::Param>(GetArena());
  }
  return _impl_.node_.param_;
}
inline ::pg_query::Param* Node::mutable_param() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Param* _msg = _internal_mutable_param();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.param)
  return _msg;
}

// .pg_query.Aggref aggref = 7 [json_name = "Aggref"];
inline bool Node::has_aggref() const {
  return node_case() == kAggref;
}
inline bool Node::_internal_has_aggref() const {
  return node_case() == kAggref;
}
inline void Node::set_has_aggref() {
  _impl_._oneof_case_[0] = kAggref;
}
inline void Node::clear_aggref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAggref) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.aggref_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Aggref* Node::release_aggref() {
  // @@protoc_insertion_point(field_release:pg_query.Node.aggref)
  if (node_case() == kAggref) {
    clear_has_node();
    auto* temp = _impl_.node_.aggref_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.aggref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Aggref& Node::_internal_aggref() const {
  return node_case() == kAggref ? *_impl_.node_.aggref_ : reinterpret_cast<::pg_query::Aggref&>(::pg_query::_Aggref_default_instance_);
}
inline const ::pg_query::Aggref& Node::aggref() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAggref) {
    clear_has_node();
    auto* temp = _impl_.node_.aggref_;
    _impl_.node_.aggref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_aggref(::pg_query::Aggref* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_aggref();
    _impl_.node_.aggref_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.aggref)
}
inline ::pg_query::Aggref* Node::_internal_mutable_aggref() {
  if (node_case() != kAggref) {
    clear_node();
    set_has_aggref();
    _impl_.node_.aggref_ = CreateMaybeMessage<::pg_query::Aggref>(GetArena());
  }
  return _impl_.node_.aggref_;
}
inline ::pg_query::Aggref* Node::mutable_aggref() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Aggref* _msg = _internal_mutable_aggref();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.aggref)
  return _msg;
}

// .pg_query.GroupingFunc grouping_func = 8 [json_name = "GroupingFunc"];
inline bool Node::has_grouping_func() const {
  return node_case() == kGroupingFunc;
}
inline bool Node::_internal_has_grouping_func() const {
  return node_case() == kGroupingFunc;
}
inline void Node::set_has_grouping_func() {
  _impl_._oneof_case_[0] = kGroupingFunc;
}
inline void Node::clear_grouping_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kGroupingFunc) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kGroupingFunc) {
    clear_has_node();
    auto* temp = _impl_.node_.grouping_func_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.grouping_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::GroupingFunc& Node::_internal_grouping_func() const {
  return node_case() == kGroupingFunc ? *_impl_.node_.grouping_func_ : reinterpret_cast<::pg_query::GroupingFunc&>(::pg_query::_GroupingFunc_default_instance_);
}
inline const ::pg_query::GroupingFunc& Node::grouping_func() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kGroupingFunc) {
    clear_has_node();
    auto* temp = _impl_.node_.grouping_func_;
    _impl_.node_.grouping_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_grouping_func(::pg_query::GroupingFunc* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_grouping_func();
    _impl_.node_.grouping_func_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.grouping_func)
}
inline ::pg_query::GroupingFunc* Node::_internal_mutable_grouping_func() {
  if (node_case() != kGroupingFunc) {
    clear_node();
    set_has_grouping_func();
    _impl_.node_.grouping_func_ = CreateMaybeMessage<::pg_query::GroupingFunc>(GetArena());
  }
  return _impl_.node_.grouping_func_;
}
inline ::pg_query::GroupingFunc* Node::mutable_grouping_func() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::GroupingFunc* _msg = _internal_mutable_grouping_func();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.grouping_func)
  return _msg;
}

// .pg_query.WindowFunc window_func = 9 [json_name = "WindowFunc"];
inline bool Node::has_window_func() const {
  return node_case() == kWindowFunc;
}
inline bool Node::_internal_has_window_func() const {
  return node_case() == kWindowFunc;
}
inline void Node::set_has_window_func() {
  _impl_._oneof_case_[0] = kWindowFunc;
}
inline void Node::clear_window_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kWindowFunc) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kWindowFunc) {
    clear_has_node();
    auto* temp = _impl_.node_.window_func_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.window_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::WindowFunc& Node::_internal_window_func() const {
  return node_case() == kWindowFunc ? *_impl_.node_.window_func_ : reinterpret_cast<::pg_query::WindowFunc&>(::pg_query::_WindowFunc_default_instance_);
}
inline const ::pg_query::WindowFunc& Node::window_func() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kWindowFunc) {
    clear_has_node();
    auto* temp = _impl_.node_.window_func_;
    _impl_.node_.window_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_window_func(::pg_query::WindowFunc* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_window_func();
    _impl_.node_.window_func_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.window_func)
}
inline ::pg_query::WindowFunc* Node::_internal_mutable_window_func() {
  if (node_case() != kWindowFunc) {
    clear_node();
    set_has_window_func();
    _impl_.node_.window_func_ = CreateMaybeMessage<::pg_query::WindowFunc>(GetArena());
  }
  return _impl_.node_.window_func_;
}
inline ::pg_query::WindowFunc* Node::mutable_window_func() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::WindowFunc* _msg = _internal_mutable_window_func();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.window_func)
  return _msg;
}

// .pg_query.SubscriptingRef subscripting_ref = 10 [json_name = "SubscriptingRef"];
inline bool Node::has_subscripting_ref() const {
  return node_case() == kSubscriptingRef;
}
inline bool Node::_internal_has_subscripting_ref() const {
  return node_case() == kSubscriptingRef;
}
inline void Node::set_has_subscripting_ref() {
  _impl_._oneof_case_[0] = kSubscriptingRef;
}
inline void Node::clear_subscripting_ref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kSubscriptingRef) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kSubscriptingRef) {
    clear_has_node();
    auto* temp = _impl_.node_.subscripting_ref_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.subscripting_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SubscriptingRef& Node::_internal_subscripting_ref() const {
  return node_case() == kSubscriptingRef ? *_impl_.node_.subscripting_ref_ : reinterpret_cast<::pg_query::SubscriptingRef&>(::pg_query::_SubscriptingRef_default_instance_);
}
inline const ::pg_query::SubscriptingRef& Node::subscripting_ref() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kSubscriptingRef) {
    clear_has_node();
    auto* temp = _impl_.node_.subscripting_ref_;
    _impl_.node_.subscripting_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_subscripting_ref(::pg_query::SubscriptingRef* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_subscripting_ref();
    _impl_.node_.subscripting_ref_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.subscripting_ref)
}
inline ::pg_query::SubscriptingRef* Node::_internal_mutable_subscripting_ref() {
  if (node_case() != kSubscriptingRef) {
    clear_node();
    set_has_subscripting_ref();
    _impl_.node_.subscripting_ref_ = CreateMaybeMessage<::pg_query::SubscriptingRef>(GetArena());
  }
  return _impl_.node_.subscripting_ref_;
}
inline ::pg_query::SubscriptingRef* Node::mutable_subscripting_ref() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SubscriptingRef* _msg = _internal_mutable_subscripting_ref();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.subscripting_ref)
  return _msg;
}

// .pg_query.FuncExpr func_expr = 11 [json_name = "FuncExpr"];
inline bool Node::has_func_expr() const {
  return node_case() == kFuncExpr;
}
inline bool Node::_internal_has_func_expr() const {
  return node_case() == kFuncExpr;
}
inline void Node::set_has_func_expr() {
  _impl_._oneof_case_[0] = kFuncExpr;
}
inline void Node::clear_func_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kFuncExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kFuncExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.func_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.func_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FuncExpr& Node::_internal_func_expr() const {
  return node_case() == kFuncExpr ? *_impl_.node_.func_expr_ : reinterpret_cast<::pg_query::FuncExpr&>(::pg_query::_FuncExpr_default_instance_);
}
inline const ::pg_query::FuncExpr& Node::func_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kFuncExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.func_expr_;
    _impl_.node_.func_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_func_expr(::pg_query::FuncExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_func_expr();
    _impl_.node_.func_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.func_expr)
}
inline ::pg_query::FuncExpr* Node::_internal_mutable_func_expr() {
  if (node_case() != kFuncExpr) {
    clear_node();
    set_has_func_expr();
    _impl_.node_.func_expr_ = CreateMaybeMessage<::pg_query::FuncExpr>(GetArena());
  }
  return _impl_.node_.func_expr_;
}
inline ::pg_query::FuncExpr* Node::mutable_func_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::FuncExpr* _msg = _internal_mutable_func_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.func_expr)
  return _msg;
}

// .pg_query.NamedArgExpr named_arg_expr = 12 [json_name = "NamedArgExpr"];
inline bool Node::has_named_arg_expr() const {
  return node_case() == kNamedArgExpr;
}
inline bool Node::_internal_has_named_arg_expr() const {
  return node_case() == kNamedArgExpr;
}
inline void Node::set_has_named_arg_expr() {
  _impl_._oneof_case_[0] = kNamedArgExpr;
}
inline void Node::clear_named_arg_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kNamedArgExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kNamedArgExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.named_arg_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.named_arg_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::NamedArgExpr& Node::_internal_named_arg_expr() const {
  return node_case() == kNamedArgExpr ? *_impl_.node_.named_arg_expr_ : reinterpret_cast<::pg_query::NamedArgExpr&>(::pg_query::_NamedArgExpr_default_instance_);
}
inline const ::pg_query::NamedArgExpr& Node::named_arg_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kNamedArgExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.named_arg_expr_;
    _impl_.node_.named_arg_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_named_arg_expr(::pg_query::NamedArgExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_named_arg_expr();
    _impl_.node_.named_arg_expr_ = value;
  }
  // @@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 (node_case() != kNamedArgExpr) {
    clear_node();
    set_has_named_arg_expr();
    _impl_.node_.named_arg_expr_ = CreateMaybeMessage<::pg_query::NamedArgExpr>(GetArena());
  }
  return _impl_.node_.named_arg_expr_;
}
inline ::pg_query::NamedArgExpr* Node::mutable_named_arg_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::NamedArgExpr* _msg = _internal_mutable_named_arg_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.named_arg_expr)
  return _msg;
}

// .pg_query.OpExpr op_expr = 13 [json_name = "OpExpr"];
inline bool Node::has_op_expr() const {
  return node_case() == kOpExpr;
}
inline bool Node::_internal_has_op_expr() const {
  return node_case() == kOpExpr;
}
inline void Node::set_has_op_expr() {
  _impl_._oneof_case_[0] = kOpExpr;
}
inline void Node::clear_op_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kOpExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kOpExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.op_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.op_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::OpExpr& Node::_internal_op_expr() const {
  return node_case() == kOpExpr ? *_impl_.node_.op_expr_ : reinterpret_cast<::pg_query::OpExpr&>(::pg_query::_OpExpr_default_instance_);
}
inline const ::pg_query::OpExpr& Node::op_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kOpExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.op_expr_;
    _impl_.node_.op_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_op_expr(::pg_query::OpExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_op_expr();
    _impl_.node_.op_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.op_expr)
}
inline ::pg_query::OpExpr* Node::_internal_mutable_op_expr() {
  if (node_case() != kOpExpr) {
    clear_node();
    set_has_op_expr();
    _impl_.node_.op_expr_ = CreateMaybeMessage<::pg_query::OpExpr>(GetArena());
  }
  return _impl_.node_.op_expr_;
}
inline ::pg_query::OpExpr* Node::mutable_op_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::OpExpr* _msg = _internal_mutable_op_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.op_expr)
  return _msg;
}

// .pg_query.DistinctExpr distinct_expr = 14 [json_name = "DistinctExpr"];
inline bool Node::has_distinct_expr() const {
  return node_case() == kDistinctExpr;
}
inline bool Node::_internal_has_distinct_expr() const {
  return node_case() == kDistinctExpr;
}
inline void Node::set_has_distinct_expr() {
  _impl_._oneof_case_[0] = kDistinctExpr;
}
inline void Node::clear_distinct_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDistinctExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDistinctExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.distinct_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.distinct_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DistinctExpr& Node::_internal_distinct_expr() const {
  return node_case() == kDistinctExpr ? *_impl_.node_.distinct_expr_ : reinterpret_cast<::pg_query::DistinctExpr&>(::pg_query::_DistinctExpr_default_instance_);
}
inline const ::pg_query::DistinctExpr& Node::distinct_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDistinctExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.distinct_expr_;
    _impl_.node_.distinct_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_distinct_expr(::pg_query::DistinctExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_distinct_expr();
    _impl_.node_.distinct_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.distinct_expr)
}
inline ::pg_query::DistinctExpr* Node::_internal_mutable_distinct_expr() {
  if (node_case() != kDistinctExpr) {
    clear_node();
    set_has_distinct_expr();
    _impl_.node_.distinct_expr_ = CreateMaybeMessage<::pg_query::DistinctExpr>(GetArena());
  }
  return _impl_.node_.distinct_expr_;
}
inline ::pg_query::DistinctExpr* Node::mutable_distinct_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DistinctExpr* _msg = _internal_mutable_distinct_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.distinct_expr)
  return _msg;
}

// .pg_query.NullIfExpr null_if_expr = 15 [json_name = "NullIfExpr"];
inline bool Node::has_null_if_expr() const {
  return node_case() == kNullIfExpr;
}
inline bool Node::_internal_has_null_if_expr() const {
  return node_case() == kNullIfExpr;
}
inline void Node::set_has_null_if_expr() {
  _impl_._oneof_case_[0] = kNullIfExpr;
}
inline void Node::clear_null_if_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kNullIfExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kNullIfExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.null_if_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.null_if_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::NullIfExpr& Node::_internal_null_if_expr() const {
  return node_case() == kNullIfExpr ? *_impl_.node_.null_if_expr_ : reinterpret_cast<::pg_query::NullIfExpr&>(::pg_query::_NullIfExpr_default_instance_);
}
inline const ::pg_query::NullIfExpr& Node::null_if_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kNullIfExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.null_if_expr_;
    _impl_.node_.null_if_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_null_if_expr(::pg_query::NullIfExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_null_if_expr();
    _impl_.node_.null_if_expr_ = value;
  }
  // @@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 (node_case() != kNullIfExpr) {
    clear_node();
    set_has_null_if_expr();
    _impl_.node_.null_if_expr_ = CreateMaybeMessage<::pg_query::NullIfExpr>(GetArena());
  }
  return _impl_.node_.null_if_expr_;
}
inline ::pg_query::NullIfExpr* Node::mutable_null_if_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::NullIfExpr* _msg = _internal_mutable_null_if_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.null_if_expr)
  return _msg;
}

// .pg_query.ScalarArrayOpExpr scalar_array_op_expr = 16 [json_name = "ScalarArrayOpExpr"];
inline bool Node::has_scalar_array_op_expr() const {
  return node_case() == kScalarArrayOpExpr;
}
inline bool Node::_internal_has_scalar_array_op_expr() const {
  return node_case() == kScalarArrayOpExpr;
}
inline void Node::set_has_scalar_array_op_expr() {
  _impl_._oneof_case_[0] = kScalarArrayOpExpr;
}
inline void Node::clear_scalar_array_op_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kScalarArrayOpExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kScalarArrayOpExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.scalar_array_op_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.scalar_array_op_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ScalarArrayOpExpr& Node::_internal_scalar_array_op_expr() const {
  return node_case() == kScalarArrayOpExpr ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kScalarArrayOpExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.scalar_array_op_expr_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_scalar_array_op_expr();
    _impl_.node_.scalar_array_op_expr_ = value;
  }
  // @@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 (node_case() != kScalarArrayOpExpr) {
    clear_node();
    set_has_scalar_array_op_expr();
    _impl_.node_.scalar_array_op_expr_ = CreateMaybeMessage<::pg_query::ScalarArrayOpExpr>(GetArena());
  }
  return _impl_.node_.scalar_array_op_expr_;
}
inline ::pg_query::ScalarArrayOpExpr* Node::mutable_scalar_array_op_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ScalarArrayOpExpr* _msg = _internal_mutable_scalar_array_op_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.scalar_array_op_expr)
  return _msg;
}

// .pg_query.BoolExpr bool_expr = 17 [json_name = "BoolExpr"];
inline bool Node::has_bool_expr() const {
  return node_case() == kBoolExpr;
}
inline bool Node::_internal_has_bool_expr() const {
  return node_case() == kBoolExpr;
}
inline void Node::set_has_bool_expr() {
  _impl_._oneof_case_[0] = kBoolExpr;
}
inline void Node::clear_bool_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kBoolExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kBoolExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.bool_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.bool_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::BoolExpr& Node::_internal_bool_expr() const {
  return node_case() == kBoolExpr ? *_impl_.node_.bool_expr_ : reinterpret_cast<::pg_query::BoolExpr&>(::pg_query::_BoolExpr_default_instance_);
}
inline const ::pg_query::BoolExpr& Node::bool_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kBoolExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.bool_expr_;
    _impl_.node_.bool_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_bool_expr(::pg_query::BoolExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_bool_expr();
    _impl_.node_.bool_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.bool_expr)
}
inline ::pg_query::BoolExpr* Node::_internal_mutable_bool_expr() {
  if (node_case() != kBoolExpr) {
    clear_node();
    set_has_bool_expr();
    _impl_.node_.bool_expr_ = CreateMaybeMessage<::pg_query::BoolExpr>(GetArena());
  }
  return _impl_.node_.bool_expr_;
}
inline ::pg_query::BoolExpr* Node::mutable_bool_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::BoolExpr* _msg = _internal_mutable_bool_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.bool_expr)
  return _msg;
}

// .pg_query.SubLink sub_link = 18 [json_name = "SubLink"];
inline bool Node::has_sub_link() const {
  return node_case() == kSubLink;
}
inline bool Node::_internal_has_sub_link() const {
  return node_case() == kSubLink;
}
inline void Node::set_has_sub_link() {
  _impl_._oneof_case_[0] = kSubLink;
}
inline void Node::clear_sub_link() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kSubLink) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kSubLink) {
    clear_has_node();
    auto* temp = _impl_.node_.sub_link_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.sub_link_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SubLink& Node::_internal_sub_link() const {
  return node_case() == kSubLink ? *_impl_.node_.sub_link_ : reinterpret_cast<::pg_query::SubLink&>(::pg_query::_SubLink_default_instance_);
}
inline const ::pg_query::SubLink& Node::sub_link() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kSubLink) {
    clear_has_node();
    auto* temp = _impl_.node_.sub_link_;
    _impl_.node_.sub_link_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_sub_link(::pg_query::SubLink* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_sub_link();
    _impl_.node_.sub_link_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sub_link)
}
inline ::pg_query::SubLink* Node::_internal_mutable_sub_link() {
  if (node_case() != kSubLink) {
    clear_node();
    set_has_sub_link();
    _impl_.node_.sub_link_ = CreateMaybeMessage<::pg_query::SubLink>(GetArena());
  }
  return _impl_.node_.sub_link_;
}
inline ::pg_query::SubLink* Node::mutable_sub_link() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SubLink* _msg = _internal_mutable_sub_link();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.sub_link)
  return _msg;
}

// .pg_query.SubPlan sub_plan = 19 [json_name = "SubPlan"];
inline bool Node::has_sub_plan() const {
  return node_case() == kSubPlan;
}
inline bool Node::_internal_has_sub_plan() const {
  return node_case() == kSubPlan;
}
inline void Node::set_has_sub_plan() {
  _impl_._oneof_case_[0] = kSubPlan;
}
inline void Node::clear_sub_plan() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kSubPlan) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kSubPlan) {
    clear_has_node();
    auto* temp = _impl_.node_.sub_plan_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.sub_plan_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SubPlan& Node::_internal_sub_plan() const {
  return node_case() == kSubPlan ? *_impl_.node_.sub_plan_ : reinterpret_cast<::pg_query::SubPlan&>(::pg_query::_SubPlan_default_instance_);
}
inline const ::pg_query::SubPlan& Node::sub_plan() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kSubPlan) {
    clear_has_node();
    auto* temp = _impl_.node_.sub_plan_;
    _impl_.node_.sub_plan_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_sub_plan(::pg_query::SubPlan* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_sub_plan();
    _impl_.node_.sub_plan_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sub_plan)
}
inline ::pg_query::SubPlan* Node::_internal_mutable_sub_plan() {
  if (node_case() != kSubPlan) {
    clear_node();
    set_has_sub_plan();
    _impl_.node_.sub_plan_ = CreateMaybeMessage<::pg_query::SubPlan>(GetArena());
  }
  return _impl_.node_.sub_plan_;
}
inline ::pg_query::SubPlan* Node::mutable_sub_plan() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SubPlan* _msg = _internal_mutable_sub_plan();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.sub_plan)
  return _msg;
}

// .pg_query.AlternativeSubPlan alternative_sub_plan = 20 [json_name = "AlternativeSubPlan"];
inline bool Node::has_alternative_sub_plan() const {
  return node_case() == kAlternativeSubPlan;
}
inline bool Node::_internal_has_alternative_sub_plan() const {
  return node_case() == kAlternativeSubPlan;
}
inline void Node::set_has_alternative_sub_plan() {
  _impl_._oneof_case_[0] = kAlternativeSubPlan;
}
inline void Node::clear_alternative_sub_plan() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlternativeSubPlan) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlternativeSubPlan) {
    clear_has_node();
    auto* temp = _impl_.node_.alternative_sub_plan_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alternative_sub_plan_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlternativeSubPlan& Node::_internal_alternative_sub_plan() const {
  return node_case() == kAlternativeSubPlan ? *_impl_.node_.alternative_sub_plan_ : reinterpret_cast<::pg_query::AlternativeSubPlan&>(::pg_query::_AlternativeSubPlan_default_instance_);
}
inline const ::pg_query::AlternativeSubPlan& Node::alternative_sub_plan() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlternativeSubPlan) {
    clear_has_node();
    auto* temp = _impl_.node_.alternative_sub_plan_;
    _impl_.node_.alternative_sub_plan_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alternative_sub_plan(::pg_query::AlternativeSubPlan* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alternative_sub_plan();
    _impl_.node_.alternative_sub_plan_ = value;
  }
  // @@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 (node_case() != kAlternativeSubPlan) {
    clear_node();
    set_has_alternative_sub_plan();
    _impl_.node_.alternative_sub_plan_ = CreateMaybeMessage<::pg_query::AlternativeSubPlan>(GetArena());
  }
  return _impl_.node_.alternative_sub_plan_;
}
inline ::pg_query::AlternativeSubPlan* Node::mutable_alternative_sub_plan() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlternativeSubPlan* _msg = _internal_mutable_alternative_sub_plan();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alternative_sub_plan)
  return _msg;
}

// .pg_query.FieldSelect field_select = 21 [json_name = "FieldSelect"];
inline bool Node::has_field_select() const {
  return node_case() == kFieldSelect;
}
inline bool Node::_internal_has_field_select() const {
  return node_case() == kFieldSelect;
}
inline void Node::set_has_field_select() {
  _impl_._oneof_case_[0] = kFieldSelect;
}
inline void Node::clear_field_select() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kFieldSelect) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kFieldSelect) {
    clear_has_node();
    auto* temp = _impl_.node_.field_select_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.field_select_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FieldSelect& Node::_internal_field_select() const {
  return node_case() == kFieldSelect ? *_impl_.node_.field_select_ : reinterpret_cast<::pg_query::FieldSelect&>(::pg_query::_FieldSelect_default_instance_);
}
inline const ::pg_query::FieldSelect& Node::field_select() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kFieldSelect) {
    clear_has_node();
    auto* temp = _impl_.node_.field_select_;
    _impl_.node_.field_select_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_field_select(::pg_query::FieldSelect* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_field_select();
    _impl_.node_.field_select_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.field_select)
}
inline ::pg_query::FieldSelect* Node::_internal_mutable_field_select() {
  if (node_case() != kFieldSelect) {
    clear_node();
    set_has_field_select();
    _impl_.node_.field_select_ = CreateMaybeMessage<::pg_query::FieldSelect>(GetArena());
  }
  return _impl_.node_.field_select_;
}
inline ::pg_query::FieldSelect* Node::mutable_field_select() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::FieldSelect* _msg = _internal_mutable_field_select();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.field_select)
  return _msg;
}

// .pg_query.FieldStore field_store = 22 [json_name = "FieldStore"];
inline bool Node::has_field_store() const {
  return node_case() == kFieldStore;
}
inline bool Node::_internal_has_field_store() const {
  return node_case() == kFieldStore;
}
inline void Node::set_has_field_store() {
  _impl_._oneof_case_[0] = kFieldStore;
}
inline void Node::clear_field_store() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kFieldStore) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kFieldStore) {
    clear_has_node();
    auto* temp = _impl_.node_.field_store_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.field_store_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FieldStore& Node::_internal_field_store() const {
  return node_case() == kFieldStore ? *_impl_.node_.field_store_ : reinterpret_cast<::pg_query::FieldStore&>(::pg_query::_FieldStore_default_instance_);
}
inline const ::pg_query::FieldStore& Node::field_store() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kFieldStore) {
    clear_has_node();
    auto* temp = _impl_.node_.field_store_;
    _impl_.node_.field_store_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_field_store(::pg_query::FieldStore* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_field_store();
    _impl_.node_.field_store_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.field_store)
}
inline ::pg_query::FieldStore* Node::_internal_mutable_field_store() {
  if (node_case() != kFieldStore) {
    clear_node();
    set_has_field_store();
    _impl_.node_.field_store_ = CreateMaybeMessage<::pg_query::FieldStore>(GetArena());
  }
  return _impl_.node_.field_store_;
}
inline ::pg_query::FieldStore* Node::mutable_field_store() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::FieldStore* _msg = _internal_mutable_field_store();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.field_store)
  return _msg;
}

// .pg_query.RelabelType relabel_type = 23 [json_name = "RelabelType"];
inline bool Node::has_relabel_type() const {
  return node_case() == kRelabelType;
}
inline bool Node::_internal_has_relabel_type() const {
  return node_case() == kRelabelType;
}
inline void Node::set_has_relabel_type() {
  _impl_._oneof_case_[0] = kRelabelType;
}
inline void Node::clear_relabel_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRelabelType) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRelabelType) {
    clear_has_node();
    auto* temp = _impl_.node_.relabel_type_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.relabel_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RelabelType& Node::_internal_relabel_type() const {
  return node_case() == kRelabelType ? *_impl_.node_.relabel_type_ : reinterpret_cast<::pg_query::RelabelType&>(::pg_query::_RelabelType_default_instance_);
}
inline const ::pg_query::RelabelType& Node::relabel_type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRelabelType) {
    clear_has_node();
    auto* temp = _impl_.node_.relabel_type_;
    _impl_.node_.relabel_type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_relabel_type(::pg_query::RelabelType* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_relabel_type();
    _impl_.node_.relabel_type_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.relabel_type)
}
inline ::pg_query::RelabelType* Node::_internal_mutable_relabel_type() {
  if (node_case() != kRelabelType) {
    clear_node();
    set_has_relabel_type();
    _impl_.node_.relabel_type_ = CreateMaybeMessage<::pg_query::RelabelType>(GetArena());
  }
  return _impl_.node_.relabel_type_;
}
inline ::pg_query::RelabelType* Node::mutable_relabel_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RelabelType* _msg = _internal_mutable_relabel_type();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.relabel_type)
  return _msg;
}

// .pg_query.CoerceViaIO coerce_via_io = 24 [json_name = "CoerceViaIO"];
inline bool Node::has_coerce_via_io() const {
  return node_case() == kCoerceViaIo;
}
inline bool Node::_internal_has_coerce_via_io() const {
  return node_case() == kCoerceViaIo;
}
inline void Node::set_has_coerce_via_io() {
  _impl_._oneof_case_[0] = kCoerceViaIo;
}
inline void Node::clear_coerce_via_io() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCoerceViaIo) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCoerceViaIo) {
    clear_has_node();
    auto* temp = _impl_.node_.coerce_via_io_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.coerce_via_io_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CoerceViaIO& Node::_internal_coerce_via_io() const {
  return node_case() == kCoerceViaIo ? *_impl_.node_.coerce_via_io_ : reinterpret_cast<::pg_query::CoerceViaIO&>(::pg_query::_CoerceViaIO_default_instance_);
}
inline const ::pg_query::CoerceViaIO& Node::coerce_via_io() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCoerceViaIo) {
    clear_has_node();
    auto* temp = _impl_.node_.coerce_via_io_;
    _impl_.node_.coerce_via_io_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_coerce_via_io(::pg_query::CoerceViaIO* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_coerce_via_io();
    _impl_.node_.coerce_via_io_ = value;
  }
  // @@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 (node_case() != kCoerceViaIo) {
    clear_node();
    set_has_coerce_via_io();
    _impl_.node_.coerce_via_io_ = CreateMaybeMessage<::pg_query::CoerceViaIO>(GetArena());
  }
  return _impl_.node_.coerce_via_io_;
}
inline ::pg_query::CoerceViaIO* Node::mutable_coerce_via_io() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CoerceViaIO* _msg = _internal_mutable_coerce_via_io();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.coerce_via_io)
  return _msg;
}

// .pg_query.ArrayCoerceExpr array_coerce_expr = 25 [json_name = "ArrayCoerceExpr"];
inline bool Node::has_array_coerce_expr() const {
  return node_case() == kArrayCoerceExpr;
}
inline bool Node::_internal_has_array_coerce_expr() const {
  return node_case() == kArrayCoerceExpr;
}
inline void Node::set_has_array_coerce_expr() {
  _impl_._oneof_case_[0] = kArrayCoerceExpr;
}
inline void Node::clear_array_coerce_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kArrayCoerceExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kArrayCoerceExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.array_coerce_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.array_coerce_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ArrayCoerceExpr& Node::_internal_array_coerce_expr() const {
  return node_case() == kArrayCoerceExpr ? *_impl_.node_.array_coerce_expr_ : reinterpret_cast<::pg_query::ArrayCoerceExpr&>(::pg_query::_ArrayCoerceExpr_default_instance_);
}
inline const ::pg_query::ArrayCoerceExpr& Node::array_coerce_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kArrayCoerceExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.array_coerce_expr_;
    _impl_.node_.array_coerce_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_array_coerce_expr(::pg_query::ArrayCoerceExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_array_coerce_expr();
    _impl_.node_.array_coerce_expr_ = value;
  }
  // @@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 (node_case() != kArrayCoerceExpr) {
    clear_node();
    set_has_array_coerce_expr();
    _impl_.node_.array_coerce_expr_ = CreateMaybeMessage<::pg_query::ArrayCoerceExpr>(GetArena());
  }
  return _impl_.node_.array_coerce_expr_;
}
inline ::pg_query::ArrayCoerceExpr* Node::mutable_array_coerce_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ArrayCoerceExpr* _msg = _internal_mutable_array_coerce_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.array_coerce_expr)
  return _msg;
}

// .pg_query.ConvertRowtypeExpr convert_rowtype_expr = 26 [json_name = "ConvertRowtypeExpr"];
inline bool Node::has_convert_rowtype_expr() const {
  return node_case() == kConvertRowtypeExpr;
}
inline bool Node::_internal_has_convert_rowtype_expr() const {
  return node_case() == kConvertRowtypeExpr;
}
inline void Node::set_has_convert_rowtype_expr() {
  _impl_._oneof_case_[0] = kConvertRowtypeExpr;
}
inline void Node::clear_convert_rowtype_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kConvertRowtypeExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kConvertRowtypeExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.convert_rowtype_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.convert_rowtype_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ConvertRowtypeExpr& Node::_internal_convert_rowtype_expr() const {
  return node_case() == kConvertRowtypeExpr ? *_impl_.node_.convert_rowtype_expr_ : reinterpret_cast<::pg_query::ConvertRowtypeExpr&>(::pg_query::_ConvertRowtypeExpr_default_instance_);
}
inline const ::pg_query::ConvertRowtypeExpr& Node::convert_rowtype_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kConvertRowtypeExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.convert_rowtype_expr_;
    _impl_.node_.convert_rowtype_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_convert_rowtype_expr(::pg_query::ConvertRowtypeExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_convert_rowtype_expr();
    _impl_.node_.convert_rowtype_expr_ = value;
  }
  // @@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 (node_case() != kConvertRowtypeExpr) {
    clear_node();
    set_has_convert_rowtype_expr();
    _impl_.node_.convert_rowtype_expr_ = CreateMaybeMessage<::pg_query::ConvertRowtypeExpr>(GetArena());
  }
  return _impl_.node_.convert_rowtype_expr_;
}
inline ::pg_query::ConvertRowtypeExpr* Node::mutable_convert_rowtype_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ConvertRowtypeExpr* _msg = _internal_mutable_convert_rowtype_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.convert_rowtype_expr)
  return _msg;
}

// .pg_query.CollateExpr collate_expr = 27 [json_name = "CollateExpr"];
inline bool Node::has_collate_expr() const {
  return node_case() == kCollateExpr;
}
inline bool Node::_internal_has_collate_expr() const {
  return node_case() == kCollateExpr;
}
inline void Node::set_has_collate_expr() {
  _impl_._oneof_case_[0] = kCollateExpr;
}
inline void Node::clear_collate_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCollateExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCollateExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.collate_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.collate_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CollateExpr& Node::_internal_collate_expr() const {
  return node_case() == kCollateExpr ? *_impl_.node_.collate_expr_ : reinterpret_cast<::pg_query::CollateExpr&>(::pg_query::_CollateExpr_default_instance_);
}
inline const ::pg_query::CollateExpr& Node::collate_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCollateExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.collate_expr_;
    _impl_.node_.collate_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_collate_expr(::pg_query::CollateExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_collate_expr();
    _impl_.node_.collate_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.collate_expr)
}
inline ::pg_query::CollateExpr* Node::_internal_mutable_collate_expr() {
  if (node_case() != kCollateExpr) {
    clear_node();
    set_has_collate_expr();
    _impl_.node_.collate_expr_ = CreateMaybeMessage<::pg_query::CollateExpr>(GetArena());
  }
  return _impl_.node_.collate_expr_;
}
inline ::pg_query::CollateExpr* Node::mutable_collate_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CollateExpr* _msg = _internal_mutable_collate_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.collate_expr)
  return _msg;
}

// .pg_query.CaseExpr case_expr = 28 [json_name = "CaseExpr"];
inline bool Node::has_case_expr() const {
  return node_case() == kCaseExpr;
}
inline bool Node::_internal_has_case_expr() const {
  return node_case() == kCaseExpr;
}
inline void Node::set_has_case_expr() {
  _impl_._oneof_case_[0] = kCaseExpr;
}
inline void Node::clear_case_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCaseExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCaseExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.case_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.case_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CaseExpr& Node::_internal_case_expr() const {
  return node_case() == kCaseExpr ? *_impl_.node_.case_expr_ : reinterpret_cast<::pg_query::CaseExpr&>(::pg_query::_CaseExpr_default_instance_);
}
inline const ::pg_query::CaseExpr& Node::case_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCaseExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.case_expr_;
    _impl_.node_.case_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_case_expr(::pg_query::CaseExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_case_expr();
    _impl_.node_.case_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.case_expr)
}
inline ::pg_query::CaseExpr* Node::_internal_mutable_case_expr() {
  if (node_case() != kCaseExpr) {
    clear_node();
    set_has_case_expr();
    _impl_.node_.case_expr_ = CreateMaybeMessage<::pg_query::CaseExpr>(GetArena());
  }
  return _impl_.node_.case_expr_;
}
inline ::pg_query::CaseExpr* Node::mutable_case_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CaseExpr* _msg = _internal_mutable_case_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.case_expr)
  return _msg;
}

// .pg_query.CaseWhen case_when = 29 [json_name = "CaseWhen"];
inline bool Node::has_case_when() const {
  return node_case() == kCaseWhen;
}
inline bool Node::_internal_has_case_when() const {
  return node_case() == kCaseWhen;
}
inline void Node::set_has_case_when() {
  _impl_._oneof_case_[0] = kCaseWhen;
}
inline void Node::clear_case_when() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCaseWhen) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCaseWhen) {
    clear_has_node();
    auto* temp = _impl_.node_.case_when_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.case_when_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CaseWhen& Node::_internal_case_when() const {
  return node_case() == kCaseWhen ? *_impl_.node_.case_when_ : reinterpret_cast<::pg_query::CaseWhen&>(::pg_query::_CaseWhen_default_instance_);
}
inline const ::pg_query::CaseWhen& Node::case_when() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCaseWhen) {
    clear_has_node();
    auto* temp = _impl_.node_.case_when_;
    _impl_.node_.case_when_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_case_when(::pg_query::CaseWhen* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_case_when();
    _impl_.node_.case_when_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.case_when)
}
inline ::pg_query::CaseWhen* Node::_internal_mutable_case_when() {
  if (node_case() != kCaseWhen) {
    clear_node();
    set_has_case_when();
    _impl_.node_.case_when_ = CreateMaybeMessage<::pg_query::CaseWhen>(GetArena());
  }
  return _impl_.node_.case_when_;
}
inline ::pg_query::CaseWhen* Node::mutable_case_when() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CaseWhen* _msg = _internal_mutable_case_when();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.case_when)
  return _msg;
}

// .pg_query.CaseTestExpr case_test_expr = 30 [json_name = "CaseTestExpr"];
inline bool Node::has_case_test_expr() const {
  return node_case() == kCaseTestExpr;
}
inline bool Node::_internal_has_case_test_expr() const {
  return node_case() == kCaseTestExpr;
}
inline void Node::set_has_case_test_expr() {
  _impl_._oneof_case_[0] = kCaseTestExpr;
}
inline void Node::clear_case_test_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCaseTestExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCaseTestExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.case_test_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.case_test_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CaseTestExpr& Node::_internal_case_test_expr() const {
  return node_case() == kCaseTestExpr ? *_impl_.node_.case_test_expr_ : reinterpret_cast<::pg_query::CaseTestExpr&>(::pg_query::_CaseTestExpr_default_instance_);
}
inline const ::pg_query::CaseTestExpr& Node::case_test_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCaseTestExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.case_test_expr_;
    _impl_.node_.case_test_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_case_test_expr(::pg_query::CaseTestExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_case_test_expr();
    _impl_.node_.case_test_expr_ = value;
  }
  // @@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 (node_case() != kCaseTestExpr) {
    clear_node();
    set_has_case_test_expr();
    _impl_.node_.case_test_expr_ = CreateMaybeMessage<::pg_query::CaseTestExpr>(GetArena());
  }
  return _impl_.node_.case_test_expr_;
}
inline ::pg_query::CaseTestExpr* Node::mutable_case_test_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CaseTestExpr* _msg = _internal_mutable_case_test_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.case_test_expr)
  return _msg;
}

// .pg_query.ArrayExpr array_expr = 31 [json_name = "ArrayExpr"];
inline bool Node::has_array_expr() const {
  return node_case() == kArrayExpr;
}
inline bool Node::_internal_has_array_expr() const {
  return node_case() == kArrayExpr;
}
inline void Node::set_has_array_expr() {
  _impl_._oneof_case_[0] = kArrayExpr;
}
inline void Node::clear_array_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kArrayExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kArrayExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.array_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.array_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ArrayExpr& Node::_internal_array_expr() const {
  return node_case() == kArrayExpr ? *_impl_.node_.array_expr_ : reinterpret_cast<::pg_query::ArrayExpr&>(::pg_query::_ArrayExpr_default_instance_);
}
inline const ::pg_query::ArrayExpr& Node::array_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kArrayExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.array_expr_;
    _impl_.node_.array_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_array_expr(::pg_query::ArrayExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_array_expr();
    _impl_.node_.array_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.array_expr)
}
inline ::pg_query::ArrayExpr* Node::_internal_mutable_array_expr() {
  if (node_case() != kArrayExpr) {
    clear_node();
    set_has_array_expr();
    _impl_.node_.array_expr_ = CreateMaybeMessage<::pg_query::ArrayExpr>(GetArena());
  }
  return _impl_.node_.array_expr_;
}
inline ::pg_query::ArrayExpr* Node::mutable_array_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ArrayExpr* _msg = _internal_mutable_array_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.array_expr)
  return _msg;
}

// .pg_query.RowExpr row_expr = 32 [json_name = "RowExpr"];
inline bool Node::has_row_expr() const {
  return node_case() == kRowExpr;
}
inline bool Node::_internal_has_row_expr() const {
  return node_case() == kRowExpr;
}
inline void Node::set_has_row_expr() {
  _impl_._oneof_case_[0] = kRowExpr;
}
inline void Node::clear_row_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRowExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRowExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.row_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.row_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RowExpr& Node::_internal_row_expr() const {
  return node_case() == kRowExpr ? *_impl_.node_.row_expr_ : reinterpret_cast<::pg_query::RowExpr&>(::pg_query::_RowExpr_default_instance_);
}
inline const ::pg_query::RowExpr& Node::row_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRowExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.row_expr_;
    _impl_.node_.row_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_row_expr(::pg_query::RowExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_row_expr();
    _impl_.node_.row_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.row_expr)
}
inline ::pg_query::RowExpr* Node::_internal_mutable_row_expr() {
  if (node_case() != kRowExpr) {
    clear_node();
    set_has_row_expr();
    _impl_.node_.row_expr_ = CreateMaybeMessage<::pg_query::RowExpr>(GetArena());
  }
  return _impl_.node_.row_expr_;
}
inline ::pg_query::RowExpr* Node::mutable_row_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RowExpr* _msg = _internal_mutable_row_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.row_expr)
  return _msg;
}

// .pg_query.RowCompareExpr row_compare_expr = 33 [json_name = "RowCompareExpr"];
inline bool Node::has_row_compare_expr() const {
  return node_case() == kRowCompareExpr;
}
inline bool Node::_internal_has_row_compare_expr() const {
  return node_case() == kRowCompareExpr;
}
inline void Node::set_has_row_compare_expr() {
  _impl_._oneof_case_[0] = kRowCompareExpr;
}
inline void Node::clear_row_compare_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRowCompareExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRowCompareExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.row_compare_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.row_compare_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RowCompareExpr& Node::_internal_row_compare_expr() const {
  return node_case() == kRowCompareExpr ? *_impl_.node_.row_compare_expr_ : reinterpret_cast<::pg_query::RowCompareExpr&>(::pg_query::_RowCompareExpr_default_instance_);
}
inline const ::pg_query::RowCompareExpr& Node::row_compare_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRowCompareExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.row_compare_expr_;
    _impl_.node_.row_compare_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_row_compare_expr(::pg_query::RowCompareExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_row_compare_expr();
    _impl_.node_.row_compare_expr_ = value;
  }
  // @@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 (node_case() != kRowCompareExpr) {
    clear_node();
    set_has_row_compare_expr();
    _impl_.node_.row_compare_expr_ = CreateMaybeMessage<::pg_query::RowCompareExpr>(GetArena());
  }
  return _impl_.node_.row_compare_expr_;
}
inline ::pg_query::RowCompareExpr* Node::mutable_row_compare_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RowCompareExpr* _msg = _internal_mutable_row_compare_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.row_compare_expr)
  return _msg;
}

// .pg_query.CoalesceExpr coalesce_expr = 34 [json_name = "CoalesceExpr"];
inline bool Node::has_coalesce_expr() const {
  return node_case() == kCoalesceExpr;
}
inline bool Node::_internal_has_coalesce_expr() const {
  return node_case() == kCoalesceExpr;
}
inline void Node::set_has_coalesce_expr() {
  _impl_._oneof_case_[0] = kCoalesceExpr;
}
inline void Node::clear_coalesce_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCoalesceExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCoalesceExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.coalesce_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.coalesce_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CoalesceExpr& Node::_internal_coalesce_expr() const {
  return node_case() == kCoalesceExpr ? *_impl_.node_.coalesce_expr_ : reinterpret_cast<::pg_query::CoalesceExpr&>(::pg_query::_CoalesceExpr_default_instance_);
}
inline const ::pg_query::CoalesceExpr& Node::coalesce_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCoalesceExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.coalesce_expr_;
    _impl_.node_.coalesce_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_coalesce_expr(::pg_query::CoalesceExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_coalesce_expr();
    _impl_.node_.coalesce_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.coalesce_expr)
}
inline ::pg_query::CoalesceExpr* Node::_internal_mutable_coalesce_expr() {
  if (node_case() != kCoalesceExpr) {
    clear_node();
    set_has_coalesce_expr();
    _impl_.node_.coalesce_expr_ = CreateMaybeMessage<::pg_query::CoalesceExpr>(GetArena());
  }
  return _impl_.node_.coalesce_expr_;
}
inline ::pg_query::CoalesceExpr* Node::mutable_coalesce_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CoalesceExpr* _msg = _internal_mutable_coalesce_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.coalesce_expr)
  return _msg;
}

// .pg_query.MinMaxExpr min_max_expr = 35 [json_name = "MinMaxExpr"];
inline bool Node::has_min_max_expr() const {
  return node_case() == kMinMaxExpr;
}
inline bool Node::_internal_has_min_max_expr() const {
  return node_case() == kMinMaxExpr;
}
inline void Node::set_has_min_max_expr() {
  _impl_._oneof_case_[0] = kMinMaxExpr;
}
inline void Node::clear_min_max_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kMinMaxExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kMinMaxExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.min_max_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.min_max_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::MinMaxExpr& Node::_internal_min_max_expr() const {
  return node_case() == kMinMaxExpr ? *_impl_.node_.min_max_expr_ : reinterpret_cast<::pg_query::MinMaxExpr&>(::pg_query::_MinMaxExpr_default_instance_);
}
inline const ::pg_query::MinMaxExpr& Node::min_max_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kMinMaxExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.min_max_expr_;
    _impl_.node_.min_max_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_min_max_expr(::pg_query::MinMaxExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_min_max_expr();
    _impl_.node_.min_max_expr_ = value;
  }
  // @@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 (node_case() != kMinMaxExpr) {
    clear_node();
    set_has_min_max_expr();
    _impl_.node_.min_max_expr_ = CreateMaybeMessage<::pg_query::MinMaxExpr>(GetArena());
  }
  return _impl_.node_.min_max_expr_;
}
inline ::pg_query::MinMaxExpr* Node::mutable_min_max_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::MinMaxExpr* _msg = _internal_mutable_min_max_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.min_max_expr)
  return _msg;
}

// .pg_query.SQLValueFunction sqlvalue_function = 36 [json_name = "SQLValueFunction"];
inline bool Node::has_sqlvalue_function() const {
  return node_case() == kSqlvalueFunction;
}
inline bool Node::_internal_has_sqlvalue_function() const {
  return node_case() == kSqlvalueFunction;
}
inline void Node::set_has_sqlvalue_function() {
  _impl_._oneof_case_[0] = kSqlvalueFunction;
}
inline void Node::clear_sqlvalue_function() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kSqlvalueFunction) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kSqlvalueFunction) {
    clear_has_node();
    auto* temp = _impl_.node_.sqlvalue_function_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.sqlvalue_function_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SQLValueFunction& Node::_internal_sqlvalue_function() const {
  return node_case() == kSqlvalueFunction ? *_impl_.node_.sqlvalue_function_ : reinterpret_cast<::pg_query::SQLValueFunction&>(::pg_query::_SQLValueFunction_default_instance_);
}
inline const ::pg_query::SQLValueFunction& Node::sqlvalue_function() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kSqlvalueFunction) {
    clear_has_node();
    auto* temp = _impl_.node_.sqlvalue_function_;
    _impl_.node_.sqlvalue_function_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_sqlvalue_function(::pg_query::SQLValueFunction* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_sqlvalue_function();
    _impl_.node_.sqlvalue_function_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sqlvalue_function)
}
inline ::pg_query::SQLValueFunction* Node::_internal_mutable_sqlvalue_function() {
  if (node_case() != kSqlvalueFunction) {
    clear_node();
    set_has_sqlvalue_function();
    _impl_.node_.sqlvalue_function_ = CreateMaybeMessage<::pg_query::SQLValueFunction>(GetArena());
  }
  return _impl_.node_.sqlvalue_function_;
}
inline ::pg_query::SQLValueFunction* Node::mutable_sqlvalue_function() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SQLValueFunction* _msg = _internal_mutable_sqlvalue_function();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.sqlvalue_function)
  return _msg;
}

// .pg_query.XmlExpr xml_expr = 37 [json_name = "XmlExpr"];
inline bool Node::has_xml_expr() const {
  return node_case() == kXmlExpr;
}
inline bool Node::_internal_has_xml_expr() const {
  return node_case() == kXmlExpr;
}
inline void Node::set_has_xml_expr() {
  _impl_._oneof_case_[0] = kXmlExpr;
}
inline void Node::clear_xml_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kXmlExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kXmlExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.xml_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.xml_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::XmlExpr& Node::_internal_xml_expr() const {
  return node_case() == kXmlExpr ? *_impl_.node_.xml_expr_ : reinterpret_cast<::pg_query::XmlExpr&>(::pg_query::_XmlExpr_default_instance_);
}
inline const ::pg_query::XmlExpr& Node::xml_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kXmlExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.xml_expr_;
    _impl_.node_.xml_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_xml_expr(::pg_query::XmlExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_xml_expr();
    _impl_.node_.xml_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.xml_expr)
}
inline ::pg_query::XmlExpr* Node::_internal_mutable_xml_expr() {
  if (node_case() != kXmlExpr) {
    clear_node();
    set_has_xml_expr();
    _impl_.node_.xml_expr_ = CreateMaybeMessage<::pg_query::XmlExpr>(GetArena());
  }
  return _impl_.node_.xml_expr_;
}
inline ::pg_query::XmlExpr* Node::mutable_xml_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::XmlExpr* _msg = _internal_mutable_xml_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.xml_expr)
  return _msg;
}

// .pg_query.JsonFormat json_format = 38 [json_name = "JsonFormat"];
inline bool Node::has_json_format() const {
  return node_case() == kJsonFormat;
}
inline bool Node::_internal_has_json_format() const {
  return node_case() == kJsonFormat;
}
inline void Node::set_has_json_format() {
  _impl_._oneof_case_[0] = kJsonFormat;
}
inline void Node::clear_json_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonFormat) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_format_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonFormat* Node::release_json_format() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_format)
  if (node_case() == kJsonFormat) {
    clear_has_node();
    auto* temp = _impl_.node_.json_format_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_format_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonFormat& Node::_internal_json_format() const {
  return node_case() == kJsonFormat ? *_impl_.node_.json_format_ : reinterpret_cast<::pg_query::JsonFormat&>(::pg_query::_JsonFormat_default_instance_);
}
inline const ::pg_query::JsonFormat& Node::json_format() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_format)
  return _internal_json_format();
}
inline ::pg_query::JsonFormat* Node::unsafe_arena_release_json_format() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_format)
  if (node_case() == kJsonFormat) {
    clear_has_node();
    auto* temp = _impl_.node_.json_format_;
    _impl_.node_.json_format_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_format(::pg_query::JsonFormat* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_format();
    _impl_.node_.json_format_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_format)
}
inline ::pg_query::JsonFormat* Node::_internal_mutable_json_format() {
  if (node_case() != kJsonFormat) {
    clear_node();
    set_has_json_format();
    _impl_.node_.json_format_ = CreateMaybeMessage<::pg_query::JsonFormat>(GetArena());
  }
  return _impl_.node_.json_format_;
}
inline ::pg_query::JsonFormat* Node::mutable_json_format() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonFormat* _msg = _internal_mutable_json_format();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_format)
  return _msg;
}

// .pg_query.JsonReturning json_returning = 39 [json_name = "JsonReturning"];
inline bool Node::has_json_returning() const {
  return node_case() == kJsonReturning;
}
inline bool Node::_internal_has_json_returning() const {
  return node_case() == kJsonReturning;
}
inline void Node::set_has_json_returning() {
  _impl_._oneof_case_[0] = kJsonReturning;
}
inline void Node::clear_json_returning() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonReturning) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_returning_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonReturning* Node::release_json_returning() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_returning)
  if (node_case() == kJsonReturning) {
    clear_has_node();
    auto* temp = _impl_.node_.json_returning_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_returning_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonReturning& Node::_internal_json_returning() const {
  return node_case() == kJsonReturning ? *_impl_.node_.json_returning_ : reinterpret_cast<::pg_query::JsonReturning&>(::pg_query::_JsonReturning_default_instance_);
}
inline const ::pg_query::JsonReturning& Node::json_returning() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_returning)
  return _internal_json_returning();
}
inline ::pg_query::JsonReturning* Node::unsafe_arena_release_json_returning() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_returning)
  if (node_case() == kJsonReturning) {
    clear_has_node();
    auto* temp = _impl_.node_.json_returning_;
    _impl_.node_.json_returning_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_returning(::pg_query::JsonReturning* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_returning();
    _impl_.node_.json_returning_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_returning)
}
inline ::pg_query::JsonReturning* Node::_internal_mutable_json_returning() {
  if (node_case() != kJsonReturning) {
    clear_node();
    set_has_json_returning();
    _impl_.node_.json_returning_ = CreateMaybeMessage<::pg_query::JsonReturning>(GetArena());
  }
  return _impl_.node_.json_returning_;
}
inline ::pg_query::JsonReturning* Node::mutable_json_returning() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonReturning* _msg = _internal_mutable_json_returning();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_returning)
  return _msg;
}

// .pg_query.JsonValueExpr json_value_expr = 40 [json_name = "JsonValueExpr"];
inline bool Node::has_json_value_expr() const {
  return node_case() == kJsonValueExpr;
}
inline bool Node::_internal_has_json_value_expr() const {
  return node_case() == kJsonValueExpr;
}
inline void Node::set_has_json_value_expr() {
  _impl_._oneof_case_[0] = kJsonValueExpr;
}
inline void Node::clear_json_value_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonValueExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_value_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonValueExpr* Node::release_json_value_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_value_expr)
  if (node_case() == kJsonValueExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.json_value_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_value_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonValueExpr& Node::_internal_json_value_expr() const {
  return node_case() == kJsonValueExpr ? *_impl_.node_.json_value_expr_ : reinterpret_cast<::pg_query::JsonValueExpr&>(::pg_query::_JsonValueExpr_default_instance_);
}
inline const ::pg_query::JsonValueExpr& Node::json_value_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_value_expr)
  return _internal_json_value_expr();
}
inline ::pg_query::JsonValueExpr* Node::unsafe_arena_release_json_value_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_value_expr)
  if (node_case() == kJsonValueExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.json_value_expr_;
    _impl_.node_.json_value_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_value_expr(::pg_query::JsonValueExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_value_expr();
    _impl_.node_.json_value_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_value_expr)
}
inline ::pg_query::JsonValueExpr* Node::_internal_mutable_json_value_expr() {
  if (node_case() != kJsonValueExpr) {
    clear_node();
    set_has_json_value_expr();
    _impl_.node_.json_value_expr_ = CreateMaybeMessage<::pg_query::JsonValueExpr>(GetArena());
  }
  return _impl_.node_.json_value_expr_;
}
inline ::pg_query::JsonValueExpr* Node::mutable_json_value_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonValueExpr* _msg = _internal_mutable_json_value_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_value_expr)
  return _msg;
}

// .pg_query.JsonConstructorExpr json_constructor_expr = 41 [json_name = "JsonConstructorExpr"];
inline bool Node::has_json_constructor_expr() const {
  return node_case() == kJsonConstructorExpr;
}
inline bool Node::_internal_has_json_constructor_expr() const {
  return node_case() == kJsonConstructorExpr;
}
inline void Node::set_has_json_constructor_expr() {
  _impl_._oneof_case_[0] = kJsonConstructorExpr;
}
inline void Node::clear_json_constructor_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonConstructorExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_constructor_expr_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonConstructorExpr* Node::release_json_constructor_expr() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_constructor_expr)
  if (node_case() == kJsonConstructorExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.json_constructor_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_constructor_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonConstructorExpr& Node::_internal_json_constructor_expr() const {
  return node_case() == kJsonConstructorExpr ? *_impl_.node_.json_constructor_expr_ : reinterpret_cast<::pg_query::JsonConstructorExpr&>(::pg_query::_JsonConstructorExpr_default_instance_);
}
inline const ::pg_query::JsonConstructorExpr& Node::json_constructor_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_constructor_expr)
  return _internal_json_constructor_expr();
}
inline ::pg_query::JsonConstructorExpr* Node::unsafe_arena_release_json_constructor_expr() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_constructor_expr)
  if (node_case() == kJsonConstructorExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.json_constructor_expr_;
    _impl_.node_.json_constructor_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_constructor_expr(::pg_query::JsonConstructorExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_constructor_expr();
    _impl_.node_.json_constructor_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_constructor_expr)
}
inline ::pg_query::JsonConstructorExpr* Node::_internal_mutable_json_constructor_expr() {
  if (node_case() != kJsonConstructorExpr) {
    clear_node();
    set_has_json_constructor_expr();
    _impl_.node_.json_constructor_expr_ = CreateMaybeMessage<::pg_query::JsonConstructorExpr>(GetArena());
  }
  return _impl_.node_.json_constructor_expr_;
}
inline ::pg_query::JsonConstructorExpr* Node::mutable_json_constructor_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonConstructorExpr* _msg = _internal_mutable_json_constructor_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_constructor_expr)
  return _msg;
}

// .pg_query.JsonIsPredicate json_is_predicate = 42 [json_name = "JsonIsPredicate"];
inline bool Node::has_json_is_predicate() const {
  return node_case() == kJsonIsPredicate;
}
inline bool Node::_internal_has_json_is_predicate() const {
  return node_case() == kJsonIsPredicate;
}
inline void Node::set_has_json_is_predicate() {
  _impl_._oneof_case_[0] = kJsonIsPredicate;
}
inline void Node::clear_json_is_predicate() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonIsPredicate) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_is_predicate_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonIsPredicate* Node::release_json_is_predicate() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_is_predicate)
  if (node_case() == kJsonIsPredicate) {
    clear_has_node();
    auto* temp = _impl_.node_.json_is_predicate_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_is_predicate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonIsPredicate& Node::_internal_json_is_predicate() const {
  return node_case() == kJsonIsPredicate ? *_impl_.node_.json_is_predicate_ : reinterpret_cast<::pg_query::JsonIsPredicate&>(::pg_query::_JsonIsPredicate_default_instance_);
}
inline const ::pg_query::JsonIsPredicate& Node::json_is_predicate() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_is_predicate)
  return _internal_json_is_predicate();
}
inline ::pg_query::JsonIsPredicate* Node::unsafe_arena_release_json_is_predicate() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_is_predicate)
  if (node_case() == kJsonIsPredicate) {
    clear_has_node();
    auto* temp = _impl_.node_.json_is_predicate_;
    _impl_.node_.json_is_predicate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_is_predicate(::pg_query::JsonIsPredicate* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_is_predicate();
    _impl_.node_.json_is_predicate_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_is_predicate)
}
inline ::pg_query::JsonIsPredicate* Node::_internal_mutable_json_is_predicate() {
  if (node_case() != kJsonIsPredicate) {
    clear_node();
    set_has_json_is_predicate();
    _impl_.node_.json_is_predicate_ = CreateMaybeMessage<::pg_query::JsonIsPredicate>(GetArena());
  }
  return _impl_.node_.json_is_predicate_;
}
inline ::pg_query::JsonIsPredicate* Node::mutable_json_is_predicate() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonIsPredicate* _msg = _internal_mutable_json_is_predicate();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_is_predicate)
  return _msg;
}

// .pg_query.NullTest null_test = 43 [json_name = "NullTest"];
inline bool Node::has_null_test() const {
  return node_case() == kNullTest;
}
inline bool Node::_internal_has_null_test() const {
  return node_case() == kNullTest;
}
inline void Node::set_has_null_test() {
  _impl_._oneof_case_[0] = kNullTest;
}
inline void Node::clear_null_test() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kNullTest) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kNullTest) {
    clear_has_node();
    auto* temp = _impl_.node_.null_test_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.null_test_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::NullTest& Node::_internal_null_test() const {
  return node_case() == kNullTest ? *_impl_.node_.null_test_ : reinterpret_cast<::pg_query::NullTest&>(::pg_query::_NullTest_default_instance_);
}
inline const ::pg_query::NullTest& Node::null_test() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kNullTest) {
    clear_has_node();
    auto* temp = _impl_.node_.null_test_;
    _impl_.node_.null_test_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_null_test(::pg_query::NullTest* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_null_test();
    _impl_.node_.null_test_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.null_test)
}
inline ::pg_query::NullTest* Node::_internal_mutable_null_test() {
  if (node_case() != kNullTest) {
    clear_node();
    set_has_null_test();
    _impl_.node_.null_test_ = CreateMaybeMessage<::pg_query::NullTest>(GetArena());
  }
  return _impl_.node_.null_test_;
}
inline ::pg_query::NullTest* Node::mutable_null_test() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::NullTest* _msg = _internal_mutable_null_test();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.null_test)
  return _msg;
}

// .pg_query.BooleanTest boolean_test = 44 [json_name = "BooleanTest"];
inline bool Node::has_boolean_test() const {
  return node_case() == kBooleanTest;
}
inline bool Node::_internal_has_boolean_test() const {
  return node_case() == kBooleanTest;
}
inline void Node::set_has_boolean_test() {
  _impl_._oneof_case_[0] = kBooleanTest;
}
inline void Node::clear_boolean_test() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kBooleanTest) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kBooleanTest) {
    clear_has_node();
    auto* temp = _impl_.node_.boolean_test_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.boolean_test_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::BooleanTest& Node::_internal_boolean_test() const {
  return node_case() == kBooleanTest ? *_impl_.node_.boolean_test_ : reinterpret_cast<::pg_query::BooleanTest&>(::pg_query::_BooleanTest_default_instance_);
}
inline const ::pg_query::BooleanTest& Node::boolean_test() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kBooleanTest) {
    clear_has_node();
    auto* temp = _impl_.node_.boolean_test_;
    _impl_.node_.boolean_test_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_boolean_test(::pg_query::BooleanTest* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_boolean_test();
    _impl_.node_.boolean_test_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.boolean_test)
}
inline ::pg_query::BooleanTest* Node::_internal_mutable_boolean_test() {
  if (node_case() != kBooleanTest) {
    clear_node();
    set_has_boolean_test();
    _impl_.node_.boolean_test_ = CreateMaybeMessage<::pg_query::BooleanTest>(GetArena());
  }
  return _impl_.node_.boolean_test_;
}
inline ::pg_query::BooleanTest* Node::mutable_boolean_test() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::BooleanTest* _msg = _internal_mutable_boolean_test();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.boolean_test)
  return _msg;
}

// .pg_query.CoerceToDomain coerce_to_domain = 45 [json_name = "CoerceToDomain"];
inline bool Node::has_coerce_to_domain() const {
  return node_case() == kCoerceToDomain;
}
inline bool Node::_internal_has_coerce_to_domain() const {
  return node_case() == kCoerceToDomain;
}
inline void Node::set_has_coerce_to_domain() {
  _impl_._oneof_case_[0] = kCoerceToDomain;
}
inline void Node::clear_coerce_to_domain() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCoerceToDomain) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCoerceToDomain) {
    clear_has_node();
    auto* temp = _impl_.node_.coerce_to_domain_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.coerce_to_domain_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CoerceToDomain& Node::_internal_coerce_to_domain() const {
  return node_case() == kCoerceToDomain ? *_impl_.node_.coerce_to_domain_ : reinterpret_cast<::pg_query::CoerceToDomain&>(::pg_query::_CoerceToDomain_default_instance_);
}
inline const ::pg_query::CoerceToDomain& Node::coerce_to_domain() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCoerceToDomain) {
    clear_has_node();
    auto* temp = _impl_.node_.coerce_to_domain_;
    _impl_.node_.coerce_to_domain_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_coerce_to_domain(::pg_query::CoerceToDomain* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_coerce_to_domain();
    _impl_.node_.coerce_to_domain_ = value;
  }
  // @@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 (node_case() != kCoerceToDomain) {
    clear_node();
    set_has_coerce_to_domain();
    _impl_.node_.coerce_to_domain_ = CreateMaybeMessage<::pg_query::CoerceToDomain>(GetArena());
  }
  return _impl_.node_.coerce_to_domain_;
}
inline ::pg_query::CoerceToDomain* Node::mutable_coerce_to_domain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CoerceToDomain* _msg = _internal_mutable_coerce_to_domain();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.coerce_to_domain)
  return _msg;
}

// .pg_query.CoerceToDomainValue coerce_to_domain_value = 46 [json_name = "CoerceToDomainValue"];
inline bool Node::has_coerce_to_domain_value() const {
  return node_case() == kCoerceToDomainValue;
}
inline bool Node::_internal_has_coerce_to_domain_value() const {
  return node_case() == kCoerceToDomainValue;
}
inline void Node::set_has_coerce_to_domain_value() {
  _impl_._oneof_case_[0] = kCoerceToDomainValue;
}
inline void Node::clear_coerce_to_domain_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCoerceToDomainValue) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCoerceToDomainValue) {
    clear_has_node();
    auto* temp = _impl_.node_.coerce_to_domain_value_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.coerce_to_domain_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CoerceToDomainValue& Node::_internal_coerce_to_domain_value() const {
  return node_case() == kCoerceToDomainValue ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCoerceToDomainValue) {
    clear_has_node();
    auto* temp = _impl_.node_.coerce_to_domain_value_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_coerce_to_domain_value();
    _impl_.node_.coerce_to_domain_value_ = 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 (node_case() != kCoerceToDomainValue) {
    clear_node();
    set_has_coerce_to_domain_value();
    _impl_.node_.coerce_to_domain_value_ = CreateMaybeMessage<::pg_query::CoerceToDomainValue>(GetArena());
  }
  return _impl_.node_.coerce_to_domain_value_;
}
inline ::pg_query::CoerceToDomainValue* Node::mutable_coerce_to_domain_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CoerceToDomainValue* _msg = _internal_mutable_coerce_to_domain_value();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.coerce_to_domain_value)
  return _msg;
}

// .pg_query.SetToDefault set_to_default = 47 [json_name = "SetToDefault"];
inline bool Node::has_set_to_default() const {
  return node_case() == kSetToDefault;
}
inline bool Node::_internal_has_set_to_default() const {
  return node_case() == kSetToDefault;
}
inline void Node::set_has_set_to_default() {
  _impl_._oneof_case_[0] = kSetToDefault;
}
inline void Node::clear_set_to_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kSetToDefault) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kSetToDefault) {
    clear_has_node();
    auto* temp = _impl_.node_.set_to_default_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.set_to_default_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SetToDefault& Node::_internal_set_to_default() const {
  return node_case() == kSetToDefault ? *_impl_.node_.set_to_default_ : reinterpret_cast<::pg_query::SetToDefault&>(::pg_query::_SetToDefault_default_instance_);
}
inline const ::pg_query::SetToDefault& Node::set_to_default() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kSetToDefault) {
    clear_has_node();
    auto* temp = _impl_.node_.set_to_default_;
    _impl_.node_.set_to_default_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_set_to_default(::pg_query::SetToDefault* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_set_to_default();
    _impl_.node_.set_to_default_ = value;
  }
  // @@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 (node_case() != kSetToDefault) {
    clear_node();
    set_has_set_to_default();
    _impl_.node_.set_to_default_ = CreateMaybeMessage<::pg_query::SetToDefault>(GetArena());
  }
  return _impl_.node_.set_to_default_;
}
inline ::pg_query::SetToDefault* Node::mutable_set_to_default() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SetToDefault* _msg = _internal_mutable_set_to_default();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.set_to_default)
  return _msg;
}

// .pg_query.CurrentOfExpr current_of_expr = 48 [json_name = "CurrentOfExpr"];
inline bool Node::has_current_of_expr() const {
  return node_case() == kCurrentOfExpr;
}
inline bool Node::_internal_has_current_of_expr() const {
  return node_case() == kCurrentOfExpr;
}
inline void Node::set_has_current_of_expr() {
  _impl_._oneof_case_[0] = kCurrentOfExpr;
}
inline void Node::clear_current_of_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCurrentOfExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCurrentOfExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.current_of_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.current_of_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CurrentOfExpr& Node::_internal_current_of_expr() const {
  return node_case() == kCurrentOfExpr ? *_impl_.node_.current_of_expr_ : reinterpret_cast<::pg_query::CurrentOfExpr&>(::pg_query::_CurrentOfExpr_default_instance_);
}
inline const ::pg_query::CurrentOfExpr& Node::current_of_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCurrentOfExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.current_of_expr_;
    _impl_.node_.current_of_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_current_of_expr(::pg_query::CurrentOfExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_current_of_expr();
    _impl_.node_.current_of_expr_ = value;
  }
  // @@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 (node_case() != kCurrentOfExpr) {
    clear_node();
    set_has_current_of_expr();
    _impl_.node_.current_of_expr_ = CreateMaybeMessage<::pg_query::CurrentOfExpr>(GetArena());
  }
  return _impl_.node_.current_of_expr_;
}
inline ::pg_query::CurrentOfExpr* Node::mutable_current_of_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CurrentOfExpr* _msg = _internal_mutable_current_of_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.current_of_expr)
  return _msg;
}

// .pg_query.NextValueExpr next_value_expr = 49 [json_name = "NextValueExpr"];
inline bool Node::has_next_value_expr() const {
  return node_case() == kNextValueExpr;
}
inline bool Node::_internal_has_next_value_expr() const {
  return node_case() == kNextValueExpr;
}
inline void Node::set_has_next_value_expr() {
  _impl_._oneof_case_[0] = kNextValueExpr;
}
inline void Node::clear_next_value_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kNextValueExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kNextValueExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.next_value_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.next_value_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::NextValueExpr& Node::_internal_next_value_expr() const {
  return node_case() == kNextValueExpr ? *_impl_.node_.next_value_expr_ : reinterpret_cast<::pg_query::NextValueExpr&>(::pg_query::_NextValueExpr_default_instance_);
}
inline const ::pg_query::NextValueExpr& Node::next_value_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kNextValueExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.next_value_expr_;
    _impl_.node_.next_value_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_next_value_expr(::pg_query::NextValueExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_next_value_expr();
    _impl_.node_.next_value_expr_ = value;
  }
  // @@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 (node_case() != kNextValueExpr) {
    clear_node();
    set_has_next_value_expr();
    _impl_.node_.next_value_expr_ = CreateMaybeMessage<::pg_query::NextValueExpr>(GetArena());
  }
  return _impl_.node_.next_value_expr_;
}
inline ::pg_query::NextValueExpr* Node::mutable_next_value_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::NextValueExpr* _msg = _internal_mutable_next_value_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.next_value_expr)
  return _msg;
}

// .pg_query.InferenceElem inference_elem = 50 [json_name = "InferenceElem"];
inline bool Node::has_inference_elem() const {
  return node_case() == kInferenceElem;
}
inline bool Node::_internal_has_inference_elem() const {
  return node_case() == kInferenceElem;
}
inline void Node::set_has_inference_elem() {
  _impl_._oneof_case_[0] = kInferenceElem;
}
inline void Node::clear_inference_elem() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kInferenceElem) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kInferenceElem) {
    clear_has_node();
    auto* temp = _impl_.node_.inference_elem_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.inference_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::InferenceElem& Node::_internal_inference_elem() const {
  return node_case() == kInferenceElem ? *_impl_.node_.inference_elem_ : reinterpret_cast<::pg_query::InferenceElem&>(::pg_query::_InferenceElem_default_instance_);
}
inline const ::pg_query::InferenceElem& Node::inference_elem() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kInferenceElem) {
    clear_has_node();
    auto* temp = _impl_.node_.inference_elem_;
    _impl_.node_.inference_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_inference_elem(::pg_query::InferenceElem* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_inference_elem();
    _impl_.node_.inference_elem_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.inference_elem)
}
inline ::pg_query::InferenceElem* Node::_internal_mutable_inference_elem() {
  if (node_case() != kInferenceElem) {
    clear_node();
    set_has_inference_elem();
    _impl_.node_.inference_elem_ = CreateMaybeMessage<::pg_query::InferenceElem>(GetArena());
  }
  return _impl_.node_.inference_elem_;
}
inline ::pg_query::InferenceElem* Node::mutable_inference_elem() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::InferenceElem* _msg = _internal_mutable_inference_elem();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.inference_elem)
  return _msg;
}

// .pg_query.TargetEntry target_entry = 51 [json_name = "TargetEntry"];
inline bool Node::has_target_entry() const {
  return node_case() == kTargetEntry;
}
inline bool Node::_internal_has_target_entry() const {
  return node_case() == kTargetEntry;
}
inline void Node::set_has_target_entry() {
  _impl_._oneof_case_[0] = kTargetEntry;
}
inline void Node::clear_target_entry() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kTargetEntry) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kTargetEntry) {
    clear_has_node();
    auto* temp = _impl_.node_.target_entry_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.target_entry_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TargetEntry& Node::_internal_target_entry() const {
  return node_case() == kTargetEntry ? *_impl_.node_.target_entry_ : reinterpret_cast<::pg_query::TargetEntry&>(::pg_query::_TargetEntry_default_instance_);
}
inline const ::pg_query::TargetEntry& Node::target_entry() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kTargetEntry) {
    clear_has_node();
    auto* temp = _impl_.node_.target_entry_;
    _impl_.node_.target_entry_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_target_entry(::pg_query::TargetEntry* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_target_entry();
    _impl_.node_.target_entry_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.target_entry)
}
inline ::pg_query::TargetEntry* Node::_internal_mutable_target_entry() {
  if (node_case() != kTargetEntry) {
    clear_node();
    set_has_target_entry();
    _impl_.node_.target_entry_ = CreateMaybeMessage<::pg_query::TargetEntry>(GetArena());
  }
  return _impl_.node_.target_entry_;
}
inline ::pg_query::TargetEntry* Node::mutable_target_entry() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TargetEntry* _msg = _internal_mutable_target_entry();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.target_entry)
  return _msg;
}

// .pg_query.RangeTblRef range_tbl_ref = 52 [json_name = "RangeTblRef"];
inline bool Node::has_range_tbl_ref() const {
  return node_case() == kRangeTblRef;
}
inline bool Node::_internal_has_range_tbl_ref() const {
  return node_case() == kRangeTblRef;
}
inline void Node::set_has_range_tbl_ref() {
  _impl_._oneof_case_[0] = kRangeTblRef;
}
inline void Node::clear_range_tbl_ref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRangeTblRef) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRangeTblRef) {
    clear_has_node();
    auto* temp = _impl_.node_.range_tbl_ref_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.range_tbl_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeTblRef& Node::_internal_range_tbl_ref() const {
  return node_case() == kRangeTblRef ? *_impl_.node_.range_tbl_ref_ : reinterpret_cast<::pg_query::RangeTblRef&>(::pg_query::_RangeTblRef_default_instance_);
}
inline const ::pg_query::RangeTblRef& Node::range_tbl_ref() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRangeTblRef) {
    clear_has_node();
    auto* temp = _impl_.node_.range_tbl_ref_;
    _impl_.node_.range_tbl_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_tbl_ref(::pg_query::RangeTblRef* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_range_tbl_ref();
    _impl_.node_.range_tbl_ref_ = value;
  }
  // @@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 (node_case() != kRangeTblRef) {
    clear_node();
    set_has_range_tbl_ref();
    _impl_.node_.range_tbl_ref_ = CreateMaybeMessage<::pg_query::RangeTblRef>(GetArena());
  }
  return _impl_.node_.range_tbl_ref_;
}
inline ::pg_query::RangeTblRef* Node::mutable_range_tbl_ref() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeTblRef* _msg = _internal_mutable_range_tbl_ref();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_tbl_ref)
  return _msg;
}

// .pg_query.JoinExpr join_expr = 53 [json_name = "JoinExpr"];
inline bool Node::has_join_expr() const {
  return node_case() == kJoinExpr;
}
inline bool Node::_internal_has_join_expr() const {
  return node_case() == kJoinExpr;
}
inline void Node::set_has_join_expr() {
  _impl_._oneof_case_[0] = kJoinExpr;
}
inline void Node::clear_join_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJoinExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kJoinExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.join_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.join_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JoinExpr& Node::_internal_join_expr() const {
  return node_case() == kJoinExpr ? *_impl_.node_.join_expr_ : reinterpret_cast<::pg_query::JoinExpr&>(::pg_query::_JoinExpr_default_instance_);
}
inline const ::pg_query::JoinExpr& Node::join_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kJoinExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.join_expr_;
    _impl_.node_.join_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_join_expr(::pg_query::JoinExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_join_expr();
    _impl_.node_.join_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.join_expr)
}
inline ::pg_query::JoinExpr* Node::_internal_mutable_join_expr() {
  if (node_case() != kJoinExpr) {
    clear_node();
    set_has_join_expr();
    _impl_.node_.join_expr_ = CreateMaybeMessage<::pg_query::JoinExpr>(GetArena());
  }
  return _impl_.node_.join_expr_;
}
inline ::pg_query::JoinExpr* Node::mutable_join_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JoinExpr* _msg = _internal_mutable_join_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.join_expr)
  return _msg;
}

// .pg_query.FromExpr from_expr = 54 [json_name = "FromExpr"];
inline bool Node::has_from_expr() const {
  return node_case() == kFromExpr;
}
inline bool Node::_internal_has_from_expr() const {
  return node_case() == kFromExpr;
}
inline void Node::set_has_from_expr() {
  _impl_._oneof_case_[0] = kFromExpr;
}
inline void Node::clear_from_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kFromExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kFromExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.from_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.from_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FromExpr& Node::_internal_from_expr() const {
  return node_case() == kFromExpr ? *_impl_.node_.from_expr_ : reinterpret_cast<::pg_query::FromExpr&>(::pg_query::_FromExpr_default_instance_);
}
inline const ::pg_query::FromExpr& Node::from_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kFromExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.from_expr_;
    _impl_.node_.from_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_from_expr(::pg_query::FromExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_from_expr();
    _impl_.node_.from_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.from_expr)
}
inline ::pg_query::FromExpr* Node::_internal_mutable_from_expr() {
  if (node_case() != kFromExpr) {
    clear_node();
    set_has_from_expr();
    _impl_.node_.from_expr_ = CreateMaybeMessage<::pg_query::FromExpr>(GetArena());
  }
  return _impl_.node_.from_expr_;
}
inline ::pg_query::FromExpr* Node::mutable_from_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::FromExpr* _msg = _internal_mutable_from_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.from_expr)
  return _msg;
}

// .pg_query.OnConflictExpr on_conflict_expr = 55 [json_name = "OnConflictExpr"];
inline bool Node::has_on_conflict_expr() const {
  return node_case() == kOnConflictExpr;
}
inline bool Node::_internal_has_on_conflict_expr() const {
  return node_case() == kOnConflictExpr;
}
inline void Node::set_has_on_conflict_expr() {
  _impl_._oneof_case_[0] = kOnConflictExpr;
}
inline void Node::clear_on_conflict_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kOnConflictExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kOnConflictExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.on_conflict_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.on_conflict_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::OnConflictExpr& Node::_internal_on_conflict_expr() const {
  return node_case() == kOnConflictExpr ? *_impl_.node_.on_conflict_expr_ : reinterpret_cast<::pg_query::OnConflictExpr&>(::pg_query::_OnConflictExpr_default_instance_);
}
inline const ::pg_query::OnConflictExpr& Node::on_conflict_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kOnConflictExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.on_conflict_expr_;
    _impl_.node_.on_conflict_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_on_conflict_expr(::pg_query::OnConflictExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_on_conflict_expr();
    _impl_.node_.on_conflict_expr_ = value;
  }
  // @@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 (node_case() != kOnConflictExpr) {
    clear_node();
    set_has_on_conflict_expr();
    _impl_.node_.on_conflict_expr_ = CreateMaybeMessage<::pg_query::OnConflictExpr>(GetArena());
  }
  return _impl_.node_.on_conflict_expr_;
}
inline ::pg_query::OnConflictExpr* Node::mutable_on_conflict_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::OnConflictExpr* _msg = _internal_mutable_on_conflict_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.on_conflict_expr)
  return _msg;
}

// .pg_query.Query query = 56 [json_name = "Query"];
inline bool Node::has_query() const {
  return node_case() == kQuery;
}
inline bool Node::_internal_has_query() const {
  return node_case() == kQuery;
}
inline void Node::set_has_query() {
  _impl_._oneof_case_[0] = kQuery;
}
inline void Node::clear_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kQuery) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.query_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Query* Node::release_query() {
  // @@protoc_insertion_point(field_release:pg_query.Node.query)
  if (node_case() == kQuery) {
    clear_has_node();
    auto* temp = _impl_.node_.query_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Query& Node::_internal_query() const {
  return node_case() == kQuery ? *_impl_.node_.query_ : reinterpret_cast<::pg_query::Query&>(::pg_query::_Query_default_instance_);
}
inline const ::pg_query::Query& Node::query() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kQuery) {
    clear_has_node();
    auto* temp = _impl_.node_.query_;
    _impl_.node_.query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_query(::pg_query::Query* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_query();
    _impl_.node_.query_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.query)
}
inline ::pg_query::Query* Node::_internal_mutable_query() {
  if (node_case() != kQuery) {
    clear_node();
    set_has_query();
    _impl_.node_.query_ = CreateMaybeMessage<::pg_query::Query>(GetArena());
  }
  return _impl_.node_.query_;
}
inline ::pg_query::Query* Node::mutable_query() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Query* _msg = _internal_mutable_query();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.query)
  return _msg;
}

// .pg_query.TypeName type_name = 57 [json_name = "TypeName"];
inline bool Node::has_type_name() const {
  return node_case() == kTypeName;
}
inline bool Node::_internal_has_type_name() const {
  return node_case() == kTypeName;
}
inline void Node::set_has_type_name() {
  _impl_._oneof_case_[0] = kTypeName;
}
inline void Node::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kTypeName) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kTypeName) {
    clear_has_node();
    auto* temp = _impl_.node_.type_name_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.type_name_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TypeName& Node::_internal_type_name() const {
  return node_case() == kTypeName ? *_impl_.node_.type_name_ : reinterpret_cast<::pg_query::TypeName&>(::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& Node::type_name() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kTypeName) {
    clear_has_node();
    auto* temp = _impl_.node_.type_name_;
    _impl_.node_.type_name_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_type_name(::pg_query::TypeName* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_type_name();
    _impl_.node_.type_name_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.type_name)
}
inline ::pg_query::TypeName* Node::_internal_mutable_type_name() {
  if (node_case() != kTypeName) {
    clear_node();
    set_has_type_name();
    _impl_.node_.type_name_ = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
  }
  return _impl_.node_.type_name_;
}
inline ::pg_query::TypeName* Node::mutable_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_type_name();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.type_name)
  return _msg;
}

// .pg_query.ColumnRef column_ref = 58 [json_name = "ColumnRef"];
inline bool Node::has_column_ref() const {
  return node_case() == kColumnRef;
}
inline bool Node::_internal_has_column_ref() const {
  return node_case() == kColumnRef;
}
inline void Node::set_has_column_ref() {
  _impl_._oneof_case_[0] = kColumnRef;
}
inline void Node::clear_column_ref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kColumnRef) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kColumnRef) {
    clear_has_node();
    auto* temp = _impl_.node_.column_ref_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.column_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ColumnRef& Node::_internal_column_ref() const {
  return node_case() == kColumnRef ? *_impl_.node_.column_ref_ : reinterpret_cast<::pg_query::ColumnRef&>(::pg_query::_ColumnRef_default_instance_);
}
inline const ::pg_query::ColumnRef& Node::column_ref() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kColumnRef) {
    clear_has_node();
    auto* temp = _impl_.node_.column_ref_;
    _impl_.node_.column_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_column_ref(::pg_query::ColumnRef* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_column_ref();
    _impl_.node_.column_ref_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.column_ref)
}
inline ::pg_query::ColumnRef* Node::_internal_mutable_column_ref() {
  if (node_case() != kColumnRef) {
    clear_node();
    set_has_column_ref();
    _impl_.node_.column_ref_ = CreateMaybeMessage<::pg_query::ColumnRef>(GetArena());
  }
  return _impl_.node_.column_ref_;
}
inline ::pg_query::ColumnRef* Node::mutable_column_ref() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ColumnRef* _msg = _internal_mutable_column_ref();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.column_ref)
  return _msg;
}

// .pg_query.ParamRef param_ref = 59 [json_name = "ParamRef"];
inline bool Node::has_param_ref() const {
  return node_case() == kParamRef;
}
inline bool Node::_internal_has_param_ref() const {
  return node_case() == kParamRef;
}
inline void Node::set_has_param_ref() {
  _impl_._oneof_case_[0] = kParamRef;
}
inline void Node::clear_param_ref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kParamRef) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kParamRef) {
    clear_has_node();
    auto* temp = _impl_.node_.param_ref_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.param_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ParamRef& Node::_internal_param_ref() const {
  return node_case() == kParamRef ? *_impl_.node_.param_ref_ : reinterpret_cast<::pg_query::ParamRef&>(::pg_query::_ParamRef_default_instance_);
}
inline const ::pg_query::ParamRef& Node::param_ref() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kParamRef) {
    clear_has_node();
    auto* temp = _impl_.node_.param_ref_;
    _impl_.node_.param_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_param_ref(::pg_query::ParamRef* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_param_ref();
    _impl_.node_.param_ref_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.param_ref)
}
inline ::pg_query::ParamRef* Node::_internal_mutable_param_ref() {
  if (node_case() != kParamRef) {
    clear_node();
    set_has_param_ref();
    _impl_.node_.param_ref_ = CreateMaybeMessage<::pg_query::ParamRef>(GetArena());
  }
  return _impl_.node_.param_ref_;
}
inline ::pg_query::ParamRef* Node::mutable_param_ref() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ParamRef* _msg = _internal_mutable_param_ref();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.param_ref)
  return _msg;
}

// .pg_query.A_Expr a_expr = 60 [json_name = "A_Expr"];
inline bool Node::has_a_expr() const {
  return node_case() == kAExpr;
}
inline bool Node::_internal_has_a_expr() const {
  return node_case() == kAExpr;
}
inline void Node::set_has_a_expr() {
  _impl_._oneof_case_[0] = kAExpr;
}
inline void Node::clear_a_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.a_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.a_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::A_Expr& Node::_internal_a_expr() const {
  return node_case() == kAExpr ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.a_expr_;
    _impl_.node_.a_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_a_expr(::pg_query::A_Expr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_a_expr();
    _impl_.node_.a_expr_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_expr)
}
inline ::pg_query::A_Expr* Node::_internal_mutable_a_expr() {
  if (node_case() != kAExpr) {
    clear_node();
    set_has_a_expr();
    _impl_.node_.a_expr_ = CreateMaybeMessage<::pg_query::A_Expr>(GetArena());
  }
  return _impl_.node_.a_expr_;
}
inline ::pg_query::A_Expr* Node::mutable_a_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::A_Expr* _msg = _internal_mutable_a_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.a_expr)
  return _msg;
}

// .pg_query.TypeCast type_cast = 61 [json_name = "TypeCast"];
inline bool Node::has_type_cast() const {
  return node_case() == kTypeCast;
}
inline bool Node::_internal_has_type_cast() const {
  return node_case() == kTypeCast;
}
inline void Node::set_has_type_cast() {
  _impl_._oneof_case_[0] = kTypeCast;
}
inline void Node::clear_type_cast() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kTypeCast) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kTypeCast) {
    clear_has_node();
    auto* temp = _impl_.node_.type_cast_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.type_cast_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TypeCast& Node::_internal_type_cast() const {
  return node_case() == kTypeCast ? *_impl_.node_.type_cast_ : reinterpret_cast<::pg_query::TypeCast&>(::pg_query::_TypeCast_default_instance_);
}
inline const ::pg_query::TypeCast& Node::type_cast() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kTypeCast) {
    clear_has_node();
    auto* temp = _impl_.node_.type_cast_;
    _impl_.node_.type_cast_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_type_cast(::pg_query::TypeCast* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_type_cast();
    _impl_.node_.type_cast_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.type_cast)
}
inline ::pg_query::TypeCast* Node::_internal_mutable_type_cast() {
  if (node_case() != kTypeCast) {
    clear_node();
    set_has_type_cast();
    _impl_.node_.type_cast_ = CreateMaybeMessage<::pg_query::TypeCast>(GetArena());
  }
  return _impl_.node_.type_cast_;
}
inline ::pg_query::TypeCast* Node::mutable_type_cast() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeCast* _msg = _internal_mutable_type_cast();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.type_cast)
  return _msg;
}

// .pg_query.CollateClause collate_clause = 62 [json_name = "CollateClause"];
inline bool Node::has_collate_clause() const {
  return node_case() == kCollateClause;
}
inline bool Node::_internal_has_collate_clause() const {
  return node_case() == kCollateClause;
}
inline void Node::set_has_collate_clause() {
  _impl_._oneof_case_[0] = kCollateClause;
}
inline void Node::clear_collate_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCollateClause) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCollateClause) {
    clear_has_node();
    auto* temp = _impl_.node_.collate_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.collate_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CollateClause& Node::_internal_collate_clause() const {
  return node_case() == kCollateClause ? *_impl_.node_.collate_clause_ : reinterpret_cast<::pg_query::CollateClause&>(::pg_query::_CollateClause_default_instance_);
}
inline const ::pg_query::CollateClause& Node::collate_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCollateClause) {
    clear_has_node();
    auto* temp = _impl_.node_.collate_clause_;
    _impl_.node_.collate_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_collate_clause(::pg_query::CollateClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_collate_clause();
    _impl_.node_.collate_clause_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.collate_clause)
}
inline ::pg_query::CollateClause* Node::_internal_mutable_collate_clause() {
  if (node_case() != kCollateClause) {
    clear_node();
    set_has_collate_clause();
    _impl_.node_.collate_clause_ = CreateMaybeMessage<::pg_query::CollateClause>(GetArena());
  }
  return _impl_.node_.collate_clause_;
}
inline ::pg_query::CollateClause* Node::mutable_collate_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CollateClause* _msg = _internal_mutable_collate_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.collate_clause)
  return _msg;
}

// .pg_query.RoleSpec role_spec = 63 [json_name = "RoleSpec"];
inline bool Node::has_role_spec() const {
  return node_case() == kRoleSpec;
}
inline bool Node::_internal_has_role_spec() const {
  return node_case() == kRoleSpec;
}
inline void Node::set_has_role_spec() {
  _impl_._oneof_case_[0] = kRoleSpec;
}
inline void Node::clear_role_spec() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRoleSpec) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRoleSpec) {
    clear_has_node();
    auto* temp = _impl_.node_.role_spec_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.role_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RoleSpec& Node::_internal_role_spec() const {
  return node_case() == kRoleSpec ? *_impl_.node_.role_spec_ : reinterpret_cast<::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& Node::role_spec() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRoleSpec) {
    clear_has_node();
    auto* temp = _impl_.node_.role_spec_;
    _impl_.node_.role_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_role_spec(::pg_query::RoleSpec* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_role_spec();
    _impl_.node_.role_spec_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.role_spec)
}
inline ::pg_query::RoleSpec* Node::_internal_mutable_role_spec() {
  if (node_case() != kRoleSpec) {
    clear_node();
    set_has_role_spec();
    _impl_.node_.role_spec_ = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
  }
  return _impl_.node_.role_spec_;
}
inline ::pg_query::RoleSpec* Node::mutable_role_spec() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_role_spec();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.role_spec)
  return _msg;
}

// .pg_query.FuncCall func_call = 64 [json_name = "FuncCall"];
inline bool Node::has_func_call() const {
  return node_case() == kFuncCall;
}
inline bool Node::_internal_has_func_call() const {
  return node_case() == kFuncCall;
}
inline void Node::set_has_func_call() {
  _impl_._oneof_case_[0] = kFuncCall;
}
inline void Node::clear_func_call() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kFuncCall) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kFuncCall) {
    clear_has_node();
    auto* temp = _impl_.node_.func_call_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.func_call_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FuncCall& Node::_internal_func_call() const {
  return node_case() == kFuncCall ? *_impl_.node_.func_call_ : reinterpret_cast<::pg_query::FuncCall&>(::pg_query::_FuncCall_default_instance_);
}
inline const ::pg_query::FuncCall& Node::func_call() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kFuncCall) {
    clear_has_node();
    auto* temp = _impl_.node_.func_call_;
    _impl_.node_.func_call_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_func_call(::pg_query::FuncCall* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_func_call();
    _impl_.node_.func_call_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.func_call)
}
inline ::pg_query::FuncCall* Node::_internal_mutable_func_call() {
  if (node_case() != kFuncCall) {
    clear_node();
    set_has_func_call();
    _impl_.node_.func_call_ = CreateMaybeMessage<::pg_query::FuncCall>(GetArena());
  }
  return _impl_.node_.func_call_;
}
inline ::pg_query::FuncCall* Node::mutable_func_call() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::FuncCall* _msg = _internal_mutable_func_call();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.func_call)
  return _msg;
}

// .pg_query.A_Star a_star = 65 [json_name = "A_Star"];
inline bool Node::has_a_star() const {
  return node_case() == kAStar;
}
inline bool Node::_internal_has_a_star() const {
  return node_case() == kAStar;
}
inline void Node::set_has_a_star() {
  _impl_._oneof_case_[0] = kAStar;
}
inline void Node::clear_a_star() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAStar) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAStar) {
    clear_has_node();
    auto* temp = _impl_.node_.a_star_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.a_star_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::A_Star& Node::_internal_a_star() const {
  return node_case() == kAStar ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAStar) {
    clear_has_node();
    auto* temp = _impl_.node_.a_star_;
    _impl_.node_.a_star_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_a_star(::pg_query::A_Star* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_a_star();
    _impl_.node_.a_star_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_star)
}
inline ::pg_query::A_Star* Node::_internal_mutable_a_star() {
  if (node_case() != kAStar) {
    clear_node();
    set_has_a_star();
    _impl_.node_.a_star_ = CreateMaybeMessage<::pg_query::A_Star>(GetArena());
  }
  return _impl_.node_.a_star_;
}
inline ::pg_query::A_Star* Node::mutable_a_star() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::A_Star* _msg = _internal_mutable_a_star();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.a_star)
  return _msg;
}

// .pg_query.A_Indices a_indices = 66 [json_name = "A_Indices"];
inline bool Node::has_a_indices() const {
  return node_case() == kAIndices;
}
inline bool Node::_internal_has_a_indices() const {
  return node_case() == kAIndices;
}
inline void Node::set_has_a_indices() {
  _impl_._oneof_case_[0] = kAIndices;
}
inline void Node::clear_a_indices() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAIndices) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAIndices) {
    clear_has_node();
    auto* temp = _impl_.node_.a_indices_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.a_indices_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::A_Indices& Node::_internal_a_indices() const {
  return node_case() == kAIndices ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAIndices) {
    clear_has_node();
    auto* temp = _impl_.node_.a_indices_;
    _impl_.node_.a_indices_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_a_indices(::pg_query::A_Indices* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_a_indices();
    _impl_.node_.a_indices_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_indices)
}
inline ::pg_query::A_Indices* Node::_internal_mutable_a_indices() {
  if (node_case() != kAIndices) {
    clear_node();
    set_has_a_indices();
    _impl_.node_.a_indices_ = CreateMaybeMessage<::pg_query::A_Indices>(GetArena());
  }
  return _impl_.node_.a_indices_;
}
inline ::pg_query::A_Indices* Node::mutable_a_indices() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::A_Indices* _msg = _internal_mutable_a_indices();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.a_indices)
  return _msg;
}

// .pg_query.A_Indirection a_indirection = 67 [json_name = "A_Indirection"];
inline bool Node::has_a_indirection() const {
  return node_case() == kAIndirection;
}
inline bool Node::_internal_has_a_indirection() const {
  return node_case() == kAIndirection;
}
inline void Node::set_has_a_indirection() {
  _impl_._oneof_case_[0] = kAIndirection;
}
inline void Node::clear_a_indirection() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAIndirection) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAIndirection) {
    clear_has_node();
    auto* temp = _impl_.node_.a_indirection_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.a_indirection_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::A_Indirection& Node::_internal_a_indirection() const {
  return node_case() == kAIndirection ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAIndirection) {
    clear_has_node();
    auto* temp = _impl_.node_.a_indirection_;
    _impl_.node_.a_indirection_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_a_indirection(::pg_query::A_Indirection* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_a_indirection();
    _impl_.node_.a_indirection_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_indirection)
}
inline ::pg_query::A_Indirection* Node::_internal_mutable_a_indirection() {
  if (node_case() != kAIndirection) {
    clear_node();
    set_has_a_indirection();
    _impl_.node_.a_indirection_ = CreateMaybeMessage<::pg_query::A_Indirection>(GetArena());
  }
  return _impl_.node_.a_indirection_;
}
inline ::pg_query::A_Indirection* Node::mutable_a_indirection() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::A_Indirection* _msg = _internal_mutable_a_indirection();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.a_indirection)
  return _msg;
}

// .pg_query.A_ArrayExpr a_array_expr = 68 [json_name = "A_ArrayExpr"];
inline bool Node::has_a_array_expr() const {
  return node_case() == kAArrayExpr;
}
inline bool Node::_internal_has_a_array_expr() const {
  return node_case() == kAArrayExpr;
}
inline void Node::set_has_a_array_expr() {
  _impl_._oneof_case_[0] = kAArrayExpr;
}
inline void Node::clear_a_array_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAArrayExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAArrayExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.a_array_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.a_array_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::A_ArrayExpr& Node::_internal_a_array_expr() const {
  return node_case() == kAArrayExpr ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAArrayExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.a_array_expr_;
    _impl_.node_.a_array_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_a_array_expr(::pg_query::A_ArrayExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_a_array_expr();
    _impl_.node_.a_array_expr_ = value;
  }
  // @@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 (node_case() != kAArrayExpr) {
    clear_node();
    set_has_a_array_expr();
    _impl_.node_.a_array_expr_ = CreateMaybeMessage<::pg_query::A_ArrayExpr>(GetArena());
  }
  return _impl_.node_.a_array_expr_;
}
inline ::pg_query::A_ArrayExpr* Node::mutable_a_array_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::A_ArrayExpr* _msg = _internal_mutable_a_array_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.a_array_expr)
  return _msg;
}

// .pg_query.ResTarget res_target = 69 [json_name = "ResTarget"];
inline bool Node::has_res_target() const {
  return node_case() == kResTarget;
}
inline bool Node::_internal_has_res_target() const {
  return node_case() == kResTarget;
}
inline void Node::set_has_res_target() {
  _impl_._oneof_case_[0] = kResTarget;
}
inline void Node::clear_res_target() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kResTarget) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kResTarget) {
    clear_has_node();
    auto* temp = _impl_.node_.res_target_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.res_target_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ResTarget& Node::_internal_res_target() const {
  return node_case() == kResTarget ? *_impl_.node_.res_target_ : reinterpret_cast<::pg_query::ResTarget&>(::pg_query::_ResTarget_default_instance_);
}
inline const ::pg_query::ResTarget& Node::res_target() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kResTarget) {
    clear_has_node();
    auto* temp = _impl_.node_.res_target_;
    _impl_.node_.res_target_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_res_target(::pg_query::ResTarget* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_res_target();
    _impl_.node_.res_target_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.res_target)
}
inline ::pg_query::ResTarget* Node::_internal_mutable_res_target() {
  if (node_case() != kResTarget) {
    clear_node();
    set_has_res_target();
    _impl_.node_.res_target_ = CreateMaybeMessage<::pg_query::ResTarget>(GetArena());
  }
  return _impl_.node_.res_target_;
}
inline ::pg_query::ResTarget* Node::mutable_res_target() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ResTarget* _msg = _internal_mutable_res_target();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.res_target)
  return _msg;
}

// .pg_query.MultiAssignRef multi_assign_ref = 70 [json_name = "MultiAssignRef"];
inline bool Node::has_multi_assign_ref() const {
  return node_case() == kMultiAssignRef;
}
inline bool Node::_internal_has_multi_assign_ref() const {
  return node_case() == kMultiAssignRef;
}
inline void Node::set_has_multi_assign_ref() {
  _impl_._oneof_case_[0] = kMultiAssignRef;
}
inline void Node::clear_multi_assign_ref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kMultiAssignRef) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kMultiAssignRef) {
    clear_has_node();
    auto* temp = _impl_.node_.multi_assign_ref_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.multi_assign_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::MultiAssignRef& Node::_internal_multi_assign_ref() const {
  return node_case() == kMultiAssignRef ? *_impl_.node_.multi_assign_ref_ : reinterpret_cast<::pg_query::MultiAssignRef&>(::pg_query::_MultiAssignRef_default_instance_);
}
inline const ::pg_query::MultiAssignRef& Node::multi_assign_ref() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kMultiAssignRef) {
    clear_has_node();
    auto* temp = _impl_.node_.multi_assign_ref_;
    _impl_.node_.multi_assign_ref_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_multi_assign_ref(::pg_query::MultiAssignRef* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_multi_assign_ref();
    _impl_.node_.multi_assign_ref_ = value;
  }
  // @@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 (node_case() != kMultiAssignRef) {
    clear_node();
    set_has_multi_assign_ref();
    _impl_.node_.multi_assign_ref_ = CreateMaybeMessage<::pg_query::MultiAssignRef>(GetArena());
  }
  return _impl_.node_.multi_assign_ref_;
}
inline ::pg_query::MultiAssignRef* Node::mutable_multi_assign_ref() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::MultiAssignRef* _msg = _internal_mutable_multi_assign_ref();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.multi_assign_ref)
  return _msg;
}

// .pg_query.SortBy sort_by = 71 [json_name = "SortBy"];
inline bool Node::has_sort_by() const {
  return node_case() == kSortBy;
}
inline bool Node::_internal_has_sort_by() const {
  return node_case() == kSortBy;
}
inline void Node::set_has_sort_by() {
  _impl_._oneof_case_[0] = kSortBy;
}
inline void Node::clear_sort_by() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kSortBy) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kSortBy) {
    clear_has_node();
    auto* temp = _impl_.node_.sort_by_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.sort_by_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SortBy& Node::_internal_sort_by() const {
  return node_case() == kSortBy ? *_impl_.node_.sort_by_ : reinterpret_cast<::pg_query::SortBy&>(::pg_query::_SortBy_default_instance_);
}
inline const ::pg_query::SortBy& Node::sort_by() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kSortBy) {
    clear_has_node();
    auto* temp = _impl_.node_.sort_by_;
    _impl_.node_.sort_by_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_sort_by(::pg_query::SortBy* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_sort_by();
    _impl_.node_.sort_by_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sort_by)
}
inline ::pg_query::SortBy* Node::_internal_mutable_sort_by() {
  if (node_case() != kSortBy) {
    clear_node();
    set_has_sort_by();
    _impl_.node_.sort_by_ = CreateMaybeMessage<::pg_query::SortBy>(GetArena());
  }
  return _impl_.node_.sort_by_;
}
inline ::pg_query::SortBy* Node::mutable_sort_by() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SortBy* _msg = _internal_mutable_sort_by();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.sort_by)
  return _msg;
}

// .pg_query.WindowDef window_def = 72 [json_name = "WindowDef"];
inline bool Node::has_window_def() const {
  return node_case() == kWindowDef;
}
inline bool Node::_internal_has_window_def() const {
  return node_case() == kWindowDef;
}
inline void Node::set_has_window_def() {
  _impl_._oneof_case_[0] = kWindowDef;
}
inline void Node::clear_window_def() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kWindowDef) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kWindowDef) {
    clear_has_node();
    auto* temp = _impl_.node_.window_def_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.window_def_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::WindowDef& Node::_internal_window_def() const {
  return node_case() == kWindowDef ? *_impl_.node_.window_def_ : reinterpret_cast<::pg_query::WindowDef&>(::pg_query::_WindowDef_default_instance_);
}
inline const ::pg_query::WindowDef& Node::window_def() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kWindowDef) {
    clear_has_node();
    auto* temp = _impl_.node_.window_def_;
    _impl_.node_.window_def_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_window_def(::pg_query::WindowDef* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_window_def();
    _impl_.node_.window_def_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.window_def)
}
inline ::pg_query::WindowDef* Node::_internal_mutable_window_def() {
  if (node_case() != kWindowDef) {
    clear_node();
    set_has_window_def();
    _impl_.node_.window_def_ = CreateMaybeMessage<::pg_query::WindowDef>(GetArena());
  }
  return _impl_.node_.window_def_;
}
inline ::pg_query::WindowDef* Node::mutable_window_def() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::WindowDef* _msg = _internal_mutable_window_def();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.window_def)
  return _msg;
}

// .pg_query.RangeSubselect range_subselect = 73 [json_name = "RangeSubselect"];
inline bool Node::has_range_subselect() const {
  return node_case() == kRangeSubselect;
}
inline bool Node::_internal_has_range_subselect() const {
  return node_case() == kRangeSubselect;
}
inline void Node::set_has_range_subselect() {
  _impl_._oneof_case_[0] = kRangeSubselect;
}
inline void Node::clear_range_subselect() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRangeSubselect) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRangeSubselect) {
    clear_has_node();
    auto* temp = _impl_.node_.range_subselect_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.range_subselect_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeSubselect& Node::_internal_range_subselect() const {
  return node_case() == kRangeSubselect ? *_impl_.node_.range_subselect_ : reinterpret_cast<::pg_query::RangeSubselect&>(::pg_query::_RangeSubselect_default_instance_);
}
inline const ::pg_query::RangeSubselect& Node::range_subselect() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRangeSubselect) {
    clear_has_node();
    auto* temp = _impl_.node_.range_subselect_;
    _impl_.node_.range_subselect_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_subselect(::pg_query::RangeSubselect* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_range_subselect();
    _impl_.node_.range_subselect_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_subselect)
}
inline ::pg_query::RangeSubselect* Node::_internal_mutable_range_subselect() {
  if (node_case() != kRangeSubselect) {
    clear_node();
    set_has_range_subselect();
    _impl_.node_.range_subselect_ = CreateMaybeMessage<::pg_query::RangeSubselect>(GetArena());
  }
  return _impl_.node_.range_subselect_;
}
inline ::pg_query::RangeSubselect* Node::mutable_range_subselect() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeSubselect* _msg = _internal_mutable_range_subselect();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_subselect)
  return _msg;
}

// .pg_query.RangeFunction range_function = 74 [json_name = "RangeFunction"];
inline bool Node::has_range_function() const {
  return node_case() == kRangeFunction;
}
inline bool Node::_internal_has_range_function() const {
  return node_case() == kRangeFunction;
}
inline void Node::set_has_range_function() {
  _impl_._oneof_case_[0] = kRangeFunction;
}
inline void Node::clear_range_function() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRangeFunction) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRangeFunction) {
    clear_has_node();
    auto* temp = _impl_.node_.range_function_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.range_function_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeFunction& Node::_internal_range_function() const {
  return node_case() == kRangeFunction ? *_impl_.node_.range_function_ : reinterpret_cast<::pg_query::RangeFunction&>(::pg_query::_RangeFunction_default_instance_);
}
inline const ::pg_query::RangeFunction& Node::range_function() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRangeFunction) {
    clear_has_node();
    auto* temp = _impl_.node_.range_function_;
    _impl_.node_.range_function_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_function(::pg_query::RangeFunction* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_range_function();
    _impl_.node_.range_function_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_function)
}
inline ::pg_query::RangeFunction* Node::_internal_mutable_range_function() {
  if (node_case() != kRangeFunction) {
    clear_node();
    set_has_range_function();
    _impl_.node_.range_function_ = CreateMaybeMessage<::pg_query::RangeFunction>(GetArena());
  }
  return _impl_.node_.range_function_;
}
inline ::pg_query::RangeFunction* Node::mutable_range_function() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeFunction* _msg = _internal_mutable_range_function();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_function)
  return _msg;
}

// .pg_query.RangeTableFunc range_table_func = 75 [json_name = "RangeTableFunc"];
inline bool Node::has_range_table_func() const {
  return node_case() == kRangeTableFunc;
}
inline bool Node::_internal_has_range_table_func() const {
  return node_case() == kRangeTableFunc;
}
inline void Node::set_has_range_table_func() {
  _impl_._oneof_case_[0] = kRangeTableFunc;
}
inline void Node::clear_range_table_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRangeTableFunc) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRangeTableFunc) {
    clear_has_node();
    auto* temp = _impl_.node_.range_table_func_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.range_table_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeTableFunc& Node::_internal_range_table_func() const {
  return node_case() == kRangeTableFunc ? *_impl_.node_.range_table_func_ : reinterpret_cast<::pg_query::RangeTableFunc&>(::pg_query::_RangeTableFunc_default_instance_);
}
inline const ::pg_query::RangeTableFunc& Node::range_table_func() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRangeTableFunc) {
    clear_has_node();
    auto* temp = _impl_.node_.range_table_func_;
    _impl_.node_.range_table_func_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_table_func(::pg_query::RangeTableFunc* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_range_table_func();
    _impl_.node_.range_table_func_ = value;
  }
  // @@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 (node_case() != kRangeTableFunc) {
    clear_node();
    set_has_range_table_func();
    _impl_.node_.range_table_func_ = CreateMaybeMessage<::pg_query::RangeTableFunc>(GetArena());
  }
  return _impl_.node_.range_table_func_;
}
inline ::pg_query::RangeTableFunc* Node::mutable_range_table_func() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeTableFunc* _msg = _internal_mutable_range_table_func();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_table_func)
  return _msg;
}

// .pg_query.RangeTableFuncCol range_table_func_col = 76 [json_name = "RangeTableFuncCol"];
inline bool Node::has_range_table_func_col() const {
  return node_case() == kRangeTableFuncCol;
}
inline bool Node::_internal_has_range_table_func_col() const {
  return node_case() == kRangeTableFuncCol;
}
inline void Node::set_has_range_table_func_col() {
  _impl_._oneof_case_[0] = kRangeTableFuncCol;
}
inline void Node::clear_range_table_func_col() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRangeTableFuncCol) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRangeTableFuncCol) {
    clear_has_node();
    auto* temp = _impl_.node_.range_table_func_col_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.range_table_func_col_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeTableFuncCol& Node::_internal_range_table_func_col() const {
  return node_case() == kRangeTableFuncCol ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRangeTableFuncCol) {
    clear_has_node();
    auto* temp = _impl_.node_.range_table_func_col_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_range_table_func_col();
    _impl_.node_.range_table_func_col_ = value;
  }
  // @@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 (node_case() != kRangeTableFuncCol) {
    clear_node();
    set_has_range_table_func_col();
    _impl_.node_.range_table_func_col_ = CreateMaybeMessage<::pg_query::RangeTableFuncCol>(GetArena());
  }
  return _impl_.node_.range_table_func_col_;
}
inline ::pg_query::RangeTableFuncCol* Node::mutable_range_table_func_col() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeTableFuncCol* _msg = _internal_mutable_range_table_func_col();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_table_func_col)
  return _msg;
}

// .pg_query.RangeTableSample range_table_sample = 77 [json_name = "RangeTableSample"];
inline bool Node::has_range_table_sample() const {
  return node_case() == kRangeTableSample;
}
inline bool Node::_internal_has_range_table_sample() const {
  return node_case() == kRangeTableSample;
}
inline void Node::set_has_range_table_sample() {
  _impl_._oneof_case_[0] = kRangeTableSample;
}
inline void Node::clear_range_table_sample() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRangeTableSample) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRangeTableSample) {
    clear_has_node();
    auto* temp = _impl_.node_.range_table_sample_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.range_table_sample_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeTableSample& Node::_internal_range_table_sample() const {
  return node_case() == kRangeTableSample ? *_impl_.node_.range_table_sample_ : reinterpret_cast<::pg_query::RangeTableSample&>(::pg_query::_RangeTableSample_default_instance_);
}
inline const ::pg_query::RangeTableSample& Node::range_table_sample() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRangeTableSample) {
    clear_has_node();
    auto* temp = _impl_.node_.range_table_sample_;
    _impl_.node_.range_table_sample_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_table_sample(::pg_query::RangeTableSample* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_range_table_sample();
    _impl_.node_.range_table_sample_ = value;
  }
  // @@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 (node_case() != kRangeTableSample) {
    clear_node();
    set_has_range_table_sample();
    _impl_.node_.range_table_sample_ = CreateMaybeMessage<::pg_query::RangeTableSample>(GetArena());
  }
  return _impl_.node_.range_table_sample_;
}
inline ::pg_query::RangeTableSample* Node::mutable_range_table_sample() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeTableSample* _msg = _internal_mutable_range_table_sample();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_table_sample)
  return _msg;
}

// .pg_query.ColumnDef column_def = 78 [json_name = "ColumnDef"];
inline bool Node::has_column_def() const {
  return node_case() == kColumnDef;
}
inline bool Node::_internal_has_column_def() const {
  return node_case() == kColumnDef;
}
inline void Node::set_has_column_def() {
  _impl_._oneof_case_[0] = kColumnDef;
}
inline void Node::clear_column_def() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kColumnDef) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kColumnDef) {
    clear_has_node();
    auto* temp = _impl_.node_.column_def_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.column_def_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ColumnDef& Node::_internal_column_def() const {
  return node_case() == kColumnDef ? *_impl_.node_.column_def_ : reinterpret_cast<::pg_query::ColumnDef&>(::pg_query::_ColumnDef_default_instance_);
}
inline const ::pg_query::ColumnDef& Node::column_def() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kColumnDef) {
    clear_has_node();
    auto* temp = _impl_.node_.column_def_;
    _impl_.node_.column_def_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_column_def(::pg_query::ColumnDef* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_column_def();
    _impl_.node_.column_def_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.column_def)
}
inline ::pg_query::ColumnDef* Node::_internal_mutable_column_def() {
  if (node_case() != kColumnDef) {
    clear_node();
    set_has_column_def();
    _impl_.node_.column_def_ = CreateMaybeMessage<::pg_query::ColumnDef>(GetArena());
  }
  return _impl_.node_.column_def_;
}
inline ::pg_query::ColumnDef* Node::mutable_column_def() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ColumnDef* _msg = _internal_mutable_column_def();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.column_def)
  return _msg;
}

// .pg_query.TableLikeClause table_like_clause = 79 [json_name = "TableLikeClause"];
inline bool Node::has_table_like_clause() const {
  return node_case() == kTableLikeClause;
}
inline bool Node::_internal_has_table_like_clause() const {
  return node_case() == kTableLikeClause;
}
inline void Node::set_has_table_like_clause() {
  _impl_._oneof_case_[0] = kTableLikeClause;
}
inline void Node::clear_table_like_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kTableLikeClause) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kTableLikeClause) {
    clear_has_node();
    auto* temp = _impl_.node_.table_like_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.table_like_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TableLikeClause& Node::_internal_table_like_clause() const {
  return node_case() == kTableLikeClause ? *_impl_.node_.table_like_clause_ : reinterpret_cast<::pg_query::TableLikeClause&>(::pg_query::_TableLikeClause_default_instance_);
}
inline const ::pg_query::TableLikeClause& Node::table_like_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kTableLikeClause) {
    clear_has_node();
    auto* temp = _impl_.node_.table_like_clause_;
    _impl_.node_.table_like_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_table_like_clause(::pg_query::TableLikeClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_table_like_clause();
    _impl_.node_.table_like_clause_ = value;
  }
  // @@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 (node_case() != kTableLikeClause) {
    clear_node();
    set_has_table_like_clause();
    _impl_.node_.table_like_clause_ = CreateMaybeMessage<::pg_query::TableLikeClause>(GetArena());
  }
  return _impl_.node_.table_like_clause_;
}
inline ::pg_query::TableLikeClause* Node::mutable_table_like_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TableLikeClause* _msg = _internal_mutable_table_like_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.table_like_clause)
  return _msg;
}

// .pg_query.IndexElem index_elem = 80 [json_name = "IndexElem"];
inline bool Node::has_index_elem() const {
  return node_case() == kIndexElem;
}
inline bool Node::_internal_has_index_elem() const {
  return node_case() == kIndexElem;
}
inline void Node::set_has_index_elem() {
  _impl_._oneof_case_[0] = kIndexElem;
}
inline void Node::clear_index_elem() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kIndexElem) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kIndexElem) {
    clear_has_node();
    auto* temp = _impl_.node_.index_elem_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.index_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::IndexElem& Node::_internal_index_elem() const {
  return node_case() == kIndexElem ? *_impl_.node_.index_elem_ : reinterpret_cast<::pg_query::IndexElem&>(::pg_query::_IndexElem_default_instance_);
}
inline const ::pg_query::IndexElem& Node::index_elem() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kIndexElem) {
    clear_has_node();
    auto* temp = _impl_.node_.index_elem_;
    _impl_.node_.index_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_index_elem(::pg_query::IndexElem* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_index_elem();
    _impl_.node_.index_elem_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.index_elem)
}
inline ::pg_query::IndexElem* Node::_internal_mutable_index_elem() {
  if (node_case() != kIndexElem) {
    clear_node();
    set_has_index_elem();
    _impl_.node_.index_elem_ = CreateMaybeMessage<::pg_query::IndexElem>(GetArena());
  }
  return _impl_.node_.index_elem_;
}
inline ::pg_query::IndexElem* Node::mutable_index_elem() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::IndexElem* _msg = _internal_mutable_index_elem();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.index_elem)
  return _msg;
}

// .pg_query.DefElem def_elem = 81 [json_name = "DefElem"];
inline bool Node::has_def_elem() const {
  return node_case() == kDefElem;
}
inline bool Node::_internal_has_def_elem() const {
  return node_case() == kDefElem;
}
inline void Node::set_has_def_elem() {
  _impl_._oneof_case_[0] = kDefElem;
}
inline void Node::clear_def_elem() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDefElem) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDefElem) {
    clear_has_node();
    auto* temp = _impl_.node_.def_elem_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.def_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DefElem& Node::_internal_def_elem() const {
  return node_case() == kDefElem ? *_impl_.node_.def_elem_ : reinterpret_cast<::pg_query::DefElem&>(::pg_query::_DefElem_default_instance_);
}
inline const ::pg_query::DefElem& Node::def_elem() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDefElem) {
    clear_has_node();
    auto* temp = _impl_.node_.def_elem_;
    _impl_.node_.def_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_def_elem(::pg_query::DefElem* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_def_elem();
    _impl_.node_.def_elem_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.def_elem)
}
inline ::pg_query::DefElem* Node::_internal_mutable_def_elem() {
  if (node_case() != kDefElem) {
    clear_node();
    set_has_def_elem();
    _impl_.node_.def_elem_ = CreateMaybeMessage<::pg_query::DefElem>(GetArena());
  }
  return _impl_.node_.def_elem_;
}
inline ::pg_query::DefElem* Node::mutable_def_elem() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DefElem* _msg = _internal_mutable_def_elem();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.def_elem)
  return _msg;
}

// .pg_query.LockingClause locking_clause = 82 [json_name = "LockingClause"];
inline bool Node::has_locking_clause() const {
  return node_case() == kLockingClause;
}
inline bool Node::_internal_has_locking_clause() const {
  return node_case() == kLockingClause;
}
inline void Node::set_has_locking_clause() {
  _impl_._oneof_case_[0] = kLockingClause;
}
inline void Node::clear_locking_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kLockingClause) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kLockingClause) {
    clear_has_node();
    auto* temp = _impl_.node_.locking_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.locking_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::LockingClause& Node::_internal_locking_clause() const {
  return node_case() == kLockingClause ? *_impl_.node_.locking_clause_ : reinterpret_cast<::pg_query::LockingClause&>(::pg_query::_LockingClause_default_instance_);
}
inline const ::pg_query::LockingClause& Node::locking_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kLockingClause) {
    clear_has_node();
    auto* temp = _impl_.node_.locking_clause_;
    _impl_.node_.locking_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_locking_clause(::pg_query::LockingClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_locking_clause();
    _impl_.node_.locking_clause_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.locking_clause)
}
inline ::pg_query::LockingClause* Node::_internal_mutable_locking_clause() {
  if (node_case() != kLockingClause) {
    clear_node();
    set_has_locking_clause();
    _impl_.node_.locking_clause_ = CreateMaybeMessage<::pg_query::LockingClause>(GetArena());
  }
  return _impl_.node_.locking_clause_;
}
inline ::pg_query::LockingClause* Node::mutable_locking_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::LockingClause* _msg = _internal_mutable_locking_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.locking_clause)
  return _msg;
}

// .pg_query.XmlSerialize xml_serialize = 83 [json_name = "XmlSerialize"];
inline bool Node::has_xml_serialize() const {
  return node_case() == kXmlSerialize;
}
inline bool Node::_internal_has_xml_serialize() const {
  return node_case() == kXmlSerialize;
}
inline void Node::set_has_xml_serialize() {
  _impl_._oneof_case_[0] = kXmlSerialize;
}
inline void Node::clear_xml_serialize() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kXmlSerialize) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kXmlSerialize) {
    clear_has_node();
    auto* temp = _impl_.node_.xml_serialize_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.xml_serialize_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::XmlSerialize& Node::_internal_xml_serialize() const {
  return node_case() == kXmlSerialize ? *_impl_.node_.xml_serialize_ : reinterpret_cast<::pg_query::XmlSerialize&>(::pg_query::_XmlSerialize_default_instance_);
}
inline const ::pg_query::XmlSerialize& Node::xml_serialize() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kXmlSerialize) {
    clear_has_node();
    auto* temp = _impl_.node_.xml_serialize_;
    _impl_.node_.xml_serialize_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_xml_serialize(::pg_query::XmlSerialize* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_xml_serialize();
    _impl_.node_.xml_serialize_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.xml_serialize)
}
inline ::pg_query::XmlSerialize* Node::_internal_mutable_xml_serialize() {
  if (node_case() != kXmlSerialize) {
    clear_node();
    set_has_xml_serialize();
    _impl_.node_.xml_serialize_ = CreateMaybeMessage<::pg_query::XmlSerialize>(GetArena());
  }
  return _impl_.node_.xml_serialize_;
}
inline ::pg_query::XmlSerialize* Node::mutable_xml_serialize() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::XmlSerialize* _msg = _internal_mutable_xml_serialize();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.xml_serialize)
  return _msg;
}

// .pg_query.PartitionElem partition_elem = 84 [json_name = "PartitionElem"];
inline bool Node::has_partition_elem() const {
  return node_case() == kPartitionElem;
}
inline bool Node::_internal_has_partition_elem() const {
  return node_case() == kPartitionElem;
}
inline void Node::set_has_partition_elem() {
  _impl_._oneof_case_[0] = kPartitionElem;
}
inline void Node::clear_partition_elem() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kPartitionElem) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kPartitionElem) {
    clear_has_node();
    auto* temp = _impl_.node_.partition_elem_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.partition_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PartitionElem& Node::_internal_partition_elem() const {
  return node_case() == kPartitionElem ? *_impl_.node_.partition_elem_ : reinterpret_cast<::pg_query::PartitionElem&>(::pg_query::_PartitionElem_default_instance_);
}
inline const ::pg_query::PartitionElem& Node::partition_elem() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kPartitionElem) {
    clear_has_node();
    auto* temp = _impl_.node_.partition_elem_;
    _impl_.node_.partition_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_partition_elem(::pg_query::PartitionElem* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_partition_elem();
    _impl_.node_.partition_elem_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_elem)
}
inline ::pg_query::PartitionElem* Node::_internal_mutable_partition_elem() {
  if (node_case() != kPartitionElem) {
    clear_node();
    set_has_partition_elem();
    _impl_.node_.partition_elem_ = CreateMaybeMessage<::pg_query::PartitionElem>(GetArena());
  }
  return _impl_.node_.partition_elem_;
}
inline ::pg_query::PartitionElem* Node::mutable_partition_elem() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PartitionElem* _msg = _internal_mutable_partition_elem();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.partition_elem)
  return _msg;
}

// .pg_query.PartitionSpec partition_spec = 85 [json_name = "PartitionSpec"];
inline bool Node::has_partition_spec() const {
  return node_case() == kPartitionSpec;
}
inline bool Node::_internal_has_partition_spec() const {
  return node_case() == kPartitionSpec;
}
inline void Node::set_has_partition_spec() {
  _impl_._oneof_case_[0] = kPartitionSpec;
}
inline void Node::clear_partition_spec() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kPartitionSpec) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kPartitionSpec) {
    clear_has_node();
    auto* temp = _impl_.node_.partition_spec_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.partition_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PartitionSpec& Node::_internal_partition_spec() const {
  return node_case() == kPartitionSpec ? *_impl_.node_.partition_spec_ : reinterpret_cast<::pg_query::PartitionSpec&>(::pg_query::_PartitionSpec_default_instance_);
}
inline const ::pg_query::PartitionSpec& Node::partition_spec() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kPartitionSpec) {
    clear_has_node();
    auto* temp = _impl_.node_.partition_spec_;
    _impl_.node_.partition_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_partition_spec(::pg_query::PartitionSpec* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_partition_spec();
    _impl_.node_.partition_spec_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_spec)
}
inline ::pg_query::PartitionSpec* Node::_internal_mutable_partition_spec() {
  if (node_case() != kPartitionSpec) {
    clear_node();
    set_has_partition_spec();
    _impl_.node_.partition_spec_ = CreateMaybeMessage<::pg_query::PartitionSpec>(GetArena());
  }
  return _impl_.node_.partition_spec_;
}
inline ::pg_query::PartitionSpec* Node::mutable_partition_spec() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PartitionSpec* _msg = _internal_mutable_partition_spec();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.partition_spec)
  return _msg;
}

// .pg_query.PartitionBoundSpec partition_bound_spec = 86 [json_name = "PartitionBoundSpec"];
inline bool Node::has_partition_bound_spec() const {
  return node_case() == kPartitionBoundSpec;
}
inline bool Node::_internal_has_partition_bound_spec() const {
  return node_case() == kPartitionBoundSpec;
}
inline void Node::set_has_partition_bound_spec() {
  _impl_._oneof_case_[0] = kPartitionBoundSpec;
}
inline void Node::clear_partition_bound_spec() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kPartitionBoundSpec) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kPartitionBoundSpec) {
    clear_has_node();
    auto* temp = _impl_.node_.partition_bound_spec_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.partition_bound_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PartitionBoundSpec& Node::_internal_partition_bound_spec() const {
  return node_case() == kPartitionBoundSpec ? *_impl_.node_.partition_bound_spec_ : reinterpret_cast<::pg_query::PartitionBoundSpec&>(::pg_query::_PartitionBoundSpec_default_instance_);
}
inline const ::pg_query::PartitionBoundSpec& Node::partition_bound_spec() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kPartitionBoundSpec) {
    clear_has_node();
    auto* temp = _impl_.node_.partition_bound_spec_;
    _impl_.node_.partition_bound_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_partition_bound_spec(::pg_query::PartitionBoundSpec* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_partition_bound_spec();
    _impl_.node_.partition_bound_spec_ = value;
  }
  // @@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 (node_case() != kPartitionBoundSpec) {
    clear_node();
    set_has_partition_bound_spec();
    _impl_.node_.partition_bound_spec_ = CreateMaybeMessage<::pg_query::PartitionBoundSpec>(GetArena());
  }
  return _impl_.node_.partition_bound_spec_;
}
inline ::pg_query::PartitionBoundSpec* Node::mutable_partition_bound_spec() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PartitionBoundSpec* _msg = _internal_mutable_partition_bound_spec();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.partition_bound_spec)
  return _msg;
}

// .pg_query.PartitionRangeDatum partition_range_datum = 87 [json_name = "PartitionRangeDatum"];
inline bool Node::has_partition_range_datum() const {
  return node_case() == kPartitionRangeDatum;
}
inline bool Node::_internal_has_partition_range_datum() const {
  return node_case() == kPartitionRangeDatum;
}
inline void Node::set_has_partition_range_datum() {
  _impl_._oneof_case_[0] = kPartitionRangeDatum;
}
inline void Node::clear_partition_range_datum() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kPartitionRangeDatum) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kPartitionRangeDatum) {
    clear_has_node();
    auto* temp = _impl_.node_.partition_range_datum_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.partition_range_datum_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PartitionRangeDatum& Node::_internal_partition_range_datum() const {
  return node_case() == kPartitionRangeDatum ? *_impl_.node_.partition_range_datum_ : reinterpret_cast<::pg_query::PartitionRangeDatum&>(::pg_query::_PartitionRangeDatum_default_instance_);
}
inline const ::pg_query::PartitionRangeDatum& Node::partition_range_datum() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kPartitionRangeDatum) {
    clear_has_node();
    auto* temp = _impl_.node_.partition_range_datum_;
    _impl_.node_.partition_range_datum_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_partition_range_datum(::pg_query::PartitionRangeDatum* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_partition_range_datum();
    _impl_.node_.partition_range_datum_ = value;
  }
  // @@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 (node_case() != kPartitionRangeDatum) {
    clear_node();
    set_has_partition_range_datum();
    _impl_.node_.partition_range_datum_ = CreateMaybeMessage<::pg_query::PartitionRangeDatum>(GetArena());
  }
  return _impl_.node_.partition_range_datum_;
}
inline ::pg_query::PartitionRangeDatum* Node::mutable_partition_range_datum() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PartitionRangeDatum* _msg = _internal_mutable_partition_range_datum();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.partition_range_datum)
  return _msg;
}

// .pg_query.PartitionCmd partition_cmd = 88 [json_name = "PartitionCmd"];
inline bool Node::has_partition_cmd() const {
  return node_case() == kPartitionCmd;
}
inline bool Node::_internal_has_partition_cmd() const {
  return node_case() == kPartitionCmd;
}
inline void Node::set_has_partition_cmd() {
  _impl_._oneof_case_[0] = kPartitionCmd;
}
inline void Node::clear_partition_cmd() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kPartitionCmd) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kPartitionCmd) {
    clear_has_node();
    auto* temp = _impl_.node_.partition_cmd_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.partition_cmd_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PartitionCmd& Node::_internal_partition_cmd() const {
  return node_case() == kPartitionCmd ? *_impl_.node_.partition_cmd_ : reinterpret_cast<::pg_query::PartitionCmd&>(::pg_query::_PartitionCmd_default_instance_);
}
inline const ::pg_query::PartitionCmd& Node::partition_cmd() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kPartitionCmd) {
    clear_has_node();
    auto* temp = _impl_.node_.partition_cmd_;
    _impl_.node_.partition_cmd_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_partition_cmd(::pg_query::PartitionCmd* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_partition_cmd();
    _impl_.node_.partition_cmd_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_cmd)
}
inline ::pg_query::PartitionCmd* Node::_internal_mutable_partition_cmd() {
  if (node_case() != kPartitionCmd) {
    clear_node();
    set_has_partition_cmd();
    _impl_.node_.partition_cmd_ = CreateMaybeMessage<::pg_query::PartitionCmd>(GetArena());
  }
  return _impl_.node_.partition_cmd_;
}
inline ::pg_query::PartitionCmd* Node::mutable_partition_cmd() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PartitionCmd* _msg = _internal_mutable_partition_cmd();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.partition_cmd)
  return _msg;
}

// .pg_query.RangeTblEntry range_tbl_entry = 89 [json_name = "RangeTblEntry"];
inline bool Node::has_range_tbl_entry() const {
  return node_case() == kRangeTblEntry;
}
inline bool Node::_internal_has_range_tbl_entry() const {
  return node_case() == kRangeTblEntry;
}
inline void Node::set_has_range_tbl_entry() {
  _impl_._oneof_case_[0] = kRangeTblEntry;
}
inline void Node::clear_range_tbl_entry() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRangeTblEntry) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRangeTblEntry) {
    clear_has_node();
    auto* temp = _impl_.node_.range_tbl_entry_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.range_tbl_entry_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeTblEntry& Node::_internal_range_tbl_entry() const {
  return node_case() == kRangeTblEntry ? *_impl_.node_.range_tbl_entry_ : reinterpret_cast<::pg_query::RangeTblEntry&>(::pg_query::_RangeTblEntry_default_instance_);
}
inline const ::pg_query::RangeTblEntry& Node::range_tbl_entry() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRangeTblEntry) {
    clear_has_node();
    auto* temp = _impl_.node_.range_tbl_entry_;
    _impl_.node_.range_tbl_entry_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_tbl_entry(::pg_query::RangeTblEntry* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_range_tbl_entry();
    _impl_.node_.range_tbl_entry_ = value;
  }
  // @@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 (node_case() != kRangeTblEntry) {
    clear_node();
    set_has_range_tbl_entry();
    _impl_.node_.range_tbl_entry_ = CreateMaybeMessage<::pg_query::RangeTblEntry>(GetArena());
  }
  return _impl_.node_.range_tbl_entry_;
}
inline ::pg_query::RangeTblEntry* Node::mutable_range_tbl_entry() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeTblEntry* _msg = _internal_mutable_range_tbl_entry();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_tbl_entry)
  return _msg;
}

// .pg_query.RTEPermissionInfo rtepermission_info = 90 [json_name = "RTEPermissionInfo"];
inline bool Node::has_rtepermission_info() const {
  return node_case() == kRtepermissionInfo;
}
inline bool Node::_internal_has_rtepermission_info() const {
  return node_case() == kRtepermissionInfo;
}
inline void Node::set_has_rtepermission_info() {
  _impl_._oneof_case_[0] = kRtepermissionInfo;
}
inline void Node::clear_rtepermission_info() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRtepermissionInfo) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.rtepermission_info_;
    }
    clear_has_node();
  }
}
inline ::pg_query::RTEPermissionInfo* Node::release_rtepermission_info() {
  // @@protoc_insertion_point(field_release:pg_query.Node.rtepermission_info)
  if (node_case() == kRtepermissionInfo) {
    clear_has_node();
    auto* temp = _impl_.node_.rtepermission_info_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.rtepermission_info_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RTEPermissionInfo& Node::_internal_rtepermission_info() const {
  return node_case() == kRtepermissionInfo ? *_impl_.node_.rtepermission_info_ : reinterpret_cast<::pg_query::RTEPermissionInfo&>(::pg_query::_RTEPermissionInfo_default_instance_);
}
inline const ::pg_query::RTEPermissionInfo& Node::rtepermission_info() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.rtepermission_info)
  return _internal_rtepermission_info();
}
inline ::pg_query::RTEPermissionInfo* Node::unsafe_arena_release_rtepermission_info() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.rtepermission_info)
  if (node_case() == kRtepermissionInfo) {
    clear_has_node();
    auto* temp = _impl_.node_.rtepermission_info_;
    _impl_.node_.rtepermission_info_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_rtepermission_info(::pg_query::RTEPermissionInfo* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_rtepermission_info();
    _impl_.node_.rtepermission_info_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.rtepermission_info)
}
inline ::pg_query::RTEPermissionInfo* Node::_internal_mutable_rtepermission_info() {
  if (node_case() != kRtepermissionInfo) {
    clear_node();
    set_has_rtepermission_info();
    _impl_.node_.rtepermission_info_ = CreateMaybeMessage<::pg_query::RTEPermissionInfo>(GetArena());
  }
  return _impl_.node_.rtepermission_info_;
}
inline ::pg_query::RTEPermissionInfo* Node::mutable_rtepermission_info() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RTEPermissionInfo* _msg = _internal_mutable_rtepermission_info();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.rtepermission_info)
  return _msg;
}

// .pg_query.RangeTblFunction range_tbl_function = 91 [json_name = "RangeTblFunction"];
inline bool Node::has_range_tbl_function() const {
  return node_case() == kRangeTblFunction;
}
inline bool Node::_internal_has_range_tbl_function() const {
  return node_case() == kRangeTblFunction;
}
inline void Node::set_has_range_tbl_function() {
  _impl_._oneof_case_[0] = kRangeTblFunction;
}
inline void Node::clear_range_tbl_function() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRangeTblFunction) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRangeTblFunction) {
    clear_has_node();
    auto* temp = _impl_.node_.range_tbl_function_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.range_tbl_function_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RangeTblFunction& Node::_internal_range_tbl_function() const {
  return node_case() == kRangeTblFunction ? *_impl_.node_.range_tbl_function_ : reinterpret_cast<::pg_query::RangeTblFunction&>(::pg_query::_RangeTblFunction_default_instance_);
}
inline const ::pg_query::RangeTblFunction& Node::range_tbl_function() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRangeTblFunction) {
    clear_has_node();
    auto* temp = _impl_.node_.range_tbl_function_;
    _impl_.node_.range_tbl_function_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_range_tbl_function(::pg_query::RangeTblFunction* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_range_tbl_function();
    _impl_.node_.range_tbl_function_ = value;
  }
  // @@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 (node_case() != kRangeTblFunction) {
    clear_node();
    set_has_range_tbl_function();
    _impl_.node_.range_tbl_function_ = CreateMaybeMessage<::pg_query::RangeTblFunction>(GetArena());
  }
  return _impl_.node_.range_tbl_function_;
}
inline ::pg_query::RangeTblFunction* Node::mutable_range_tbl_function() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeTblFunction* _msg = _internal_mutable_range_tbl_function();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.range_tbl_function)
  return _msg;
}

// .pg_query.TableSampleClause table_sample_clause = 92 [json_name = "TableSampleClause"];
inline bool Node::has_table_sample_clause() const {
  return node_case() == kTableSampleClause;
}
inline bool Node::_internal_has_table_sample_clause() const {
  return node_case() == kTableSampleClause;
}
inline void Node::set_has_table_sample_clause() {
  _impl_._oneof_case_[0] = kTableSampleClause;
}
inline void Node::clear_table_sample_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kTableSampleClause) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kTableSampleClause) {
    clear_has_node();
    auto* temp = _impl_.node_.table_sample_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.table_sample_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TableSampleClause& Node::_internal_table_sample_clause() const {
  return node_case() == kTableSampleClause ? *_impl_.node_.table_sample_clause_ : reinterpret_cast<::pg_query::TableSampleClause&>(::pg_query::_TableSampleClause_default_instance_);
}
inline const ::pg_query::TableSampleClause& Node::table_sample_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kTableSampleClause) {
    clear_has_node();
    auto* temp = _impl_.node_.table_sample_clause_;
    _impl_.node_.table_sample_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_table_sample_clause(::pg_query::TableSampleClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_table_sample_clause();
    _impl_.node_.table_sample_clause_ = value;
  }
  // @@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 (node_case() != kTableSampleClause) {
    clear_node();
    set_has_table_sample_clause();
    _impl_.node_.table_sample_clause_ = CreateMaybeMessage<::pg_query::TableSampleClause>(GetArena());
  }
  return _impl_.node_.table_sample_clause_;
}
inline ::pg_query::TableSampleClause* Node::mutable_table_sample_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TableSampleClause* _msg = _internal_mutable_table_sample_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.table_sample_clause)
  return _msg;
}

// .pg_query.WithCheckOption with_check_option = 93 [json_name = "WithCheckOption"];
inline bool Node::has_with_check_option() const {
  return node_case() == kWithCheckOption;
}
inline bool Node::_internal_has_with_check_option() const {
  return node_case() == kWithCheckOption;
}
inline void Node::set_has_with_check_option() {
  _impl_._oneof_case_[0] = kWithCheckOption;
}
inline void Node::clear_with_check_option() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kWithCheckOption) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kWithCheckOption) {
    clear_has_node();
    auto* temp = _impl_.node_.with_check_option_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.with_check_option_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::WithCheckOption& Node::_internal_with_check_option() const {
  return node_case() == kWithCheckOption ? *_impl_.node_.with_check_option_ : reinterpret_cast<::pg_query::WithCheckOption&>(::pg_query::_WithCheckOption_default_instance_);
}
inline const ::pg_query::WithCheckOption& Node::with_check_option() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kWithCheckOption) {
    clear_has_node();
    auto* temp = _impl_.node_.with_check_option_;
    _impl_.node_.with_check_option_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_with_check_option(::pg_query::WithCheckOption* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_with_check_option();
    _impl_.node_.with_check_option_ = value;
  }
  // @@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 (node_case() != kWithCheckOption) {
    clear_node();
    set_has_with_check_option();
    _impl_.node_.with_check_option_ = CreateMaybeMessage<::pg_query::WithCheckOption>(GetArena());
  }
  return _impl_.node_.with_check_option_;
}
inline ::pg_query::WithCheckOption* Node::mutable_with_check_option() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::WithCheckOption* _msg = _internal_mutable_with_check_option();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.with_check_option)
  return _msg;
}

// .pg_query.SortGroupClause sort_group_clause = 94 [json_name = "SortGroupClause"];
inline bool Node::has_sort_group_clause() const {
  return node_case() == kSortGroupClause;
}
inline bool Node::_internal_has_sort_group_clause() const {
  return node_case() == kSortGroupClause;
}
inline void Node::set_has_sort_group_clause() {
  _impl_._oneof_case_[0] = kSortGroupClause;
}
inline void Node::clear_sort_group_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kSortGroupClause) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kSortGroupClause) {
    clear_has_node();
    auto* temp = _impl_.node_.sort_group_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.sort_group_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SortGroupClause& Node::_internal_sort_group_clause() const {
  return node_case() == kSortGroupClause ? *_impl_.node_.sort_group_clause_ : reinterpret_cast<::pg_query::SortGroupClause&>(::pg_query::_SortGroupClause_default_instance_);
}
inline const ::pg_query::SortGroupClause& Node::sort_group_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kSortGroupClause) {
    clear_has_node();
    auto* temp = _impl_.node_.sort_group_clause_;
    _impl_.node_.sort_group_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_sort_group_clause(::pg_query::SortGroupClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_sort_group_clause();
    _impl_.node_.sort_group_clause_ = value;
  }
  // @@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 (node_case() != kSortGroupClause) {
    clear_node();
    set_has_sort_group_clause();
    _impl_.node_.sort_group_clause_ = CreateMaybeMessage<::pg_query::SortGroupClause>(GetArena());
  }
  return _impl_.node_.sort_group_clause_;
}
inline ::pg_query::SortGroupClause* Node::mutable_sort_group_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SortGroupClause* _msg = _internal_mutable_sort_group_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.sort_group_clause)
  return _msg;
}

// .pg_query.GroupingSet grouping_set = 95 [json_name = "GroupingSet"];
inline bool Node::has_grouping_set() const {
  return node_case() == kGroupingSet;
}
inline bool Node::_internal_has_grouping_set() const {
  return node_case() == kGroupingSet;
}
inline void Node::set_has_grouping_set() {
  _impl_._oneof_case_[0] = kGroupingSet;
}
inline void Node::clear_grouping_set() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kGroupingSet) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kGroupingSet) {
    clear_has_node();
    auto* temp = _impl_.node_.grouping_set_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.grouping_set_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::GroupingSet& Node::_internal_grouping_set() const {
  return node_case() == kGroupingSet ? *_impl_.node_.grouping_set_ : reinterpret_cast<::pg_query::GroupingSet&>(::pg_query::_GroupingSet_default_instance_);
}
inline const ::pg_query::GroupingSet& Node::grouping_set() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kGroupingSet) {
    clear_has_node();
    auto* temp = _impl_.node_.grouping_set_;
    _impl_.node_.grouping_set_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_grouping_set(::pg_query::GroupingSet* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_grouping_set();
    _impl_.node_.grouping_set_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.grouping_set)
}
inline ::pg_query::GroupingSet* Node::_internal_mutable_grouping_set() {
  if (node_case() != kGroupingSet) {
    clear_node();
    set_has_grouping_set();
    _impl_.node_.grouping_set_ = CreateMaybeMessage<::pg_query::GroupingSet>(GetArena());
  }
  return _impl_.node_.grouping_set_;
}
inline ::pg_query::GroupingSet* Node::mutable_grouping_set() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::GroupingSet* _msg = _internal_mutable_grouping_set();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.grouping_set)
  return _msg;
}

// .pg_query.WindowClause window_clause = 96 [json_name = "WindowClause"];
inline bool Node::has_window_clause() const {
  return node_case() == kWindowClause;
}
inline bool Node::_internal_has_window_clause() const {
  return node_case() == kWindowClause;
}
inline void Node::set_has_window_clause() {
  _impl_._oneof_case_[0] = kWindowClause;
}
inline void Node::clear_window_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kWindowClause) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kWindowClause) {
    clear_has_node();
    auto* temp = _impl_.node_.window_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.window_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::WindowClause& Node::_internal_window_clause() const {
  return node_case() == kWindowClause ? *_impl_.node_.window_clause_ : reinterpret_cast<::pg_query::WindowClause&>(::pg_query::_WindowClause_default_instance_);
}
inline const ::pg_query::WindowClause& Node::window_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kWindowClause) {
    clear_has_node();
    auto* temp = _impl_.node_.window_clause_;
    _impl_.node_.window_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_window_clause(::pg_query::WindowClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_window_clause();
    _impl_.node_.window_clause_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.window_clause)
}
inline ::pg_query::WindowClause* Node::_internal_mutable_window_clause() {
  if (node_case() != kWindowClause) {
    clear_node();
    set_has_window_clause();
    _impl_.node_.window_clause_ = CreateMaybeMessage<::pg_query::WindowClause>(GetArena());
  }
  return _impl_.node_.window_clause_;
}
inline ::pg_query::WindowClause* Node::mutable_window_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::WindowClause* _msg = _internal_mutable_window_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.window_clause)
  return _msg;
}

// .pg_query.RowMarkClause row_mark_clause = 97 [json_name = "RowMarkClause"];
inline bool Node::has_row_mark_clause() const {
  return node_case() == kRowMarkClause;
}
inline bool Node::_internal_has_row_mark_clause() const {
  return node_case() == kRowMarkClause;
}
inline void Node::set_has_row_mark_clause() {
  _impl_._oneof_case_[0] = kRowMarkClause;
}
inline void Node::clear_row_mark_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRowMarkClause) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRowMarkClause) {
    clear_has_node();
    auto* temp = _impl_.node_.row_mark_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.row_mark_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RowMarkClause& Node::_internal_row_mark_clause() const {
  return node_case() == kRowMarkClause ? *_impl_.node_.row_mark_clause_ : reinterpret_cast<::pg_query::RowMarkClause&>(::pg_query::_RowMarkClause_default_instance_);
}
inline const ::pg_query::RowMarkClause& Node::row_mark_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRowMarkClause) {
    clear_has_node();
    auto* temp = _impl_.node_.row_mark_clause_;
    _impl_.node_.row_mark_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_row_mark_clause(::pg_query::RowMarkClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_row_mark_clause();
    _impl_.node_.row_mark_clause_ = value;
  }
  // @@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 (node_case() != kRowMarkClause) {
    clear_node();
    set_has_row_mark_clause();
    _impl_.node_.row_mark_clause_ = CreateMaybeMessage<::pg_query::RowMarkClause>(GetArena());
  }
  return _impl_.node_.row_mark_clause_;
}
inline ::pg_query::RowMarkClause* Node::mutable_row_mark_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RowMarkClause* _msg = _internal_mutable_row_mark_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.row_mark_clause)
  return _msg;
}

// .pg_query.WithClause with_clause = 98 [json_name = "WithClause"];
inline bool Node::has_with_clause() const {
  return node_case() == kWithClause;
}
inline bool Node::_internal_has_with_clause() const {
  return node_case() == kWithClause;
}
inline void Node::set_has_with_clause() {
  _impl_._oneof_case_[0] = kWithClause;
}
inline void Node::clear_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kWithClause) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kWithClause) {
    clear_has_node();
    auto* temp = _impl_.node_.with_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.with_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::WithClause& Node::_internal_with_clause() const {
  return node_case() == kWithClause ? *_impl_.node_.with_clause_ : reinterpret_cast<::pg_query::WithClause&>(::pg_query::_WithClause_default_instance_);
}
inline const ::pg_query::WithClause& Node::with_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kWithClause) {
    clear_has_node();
    auto* temp = _impl_.node_.with_clause_;
    _impl_.node_.with_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_with_clause(::pg_query::WithClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_with_clause();
    _impl_.node_.with_clause_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.with_clause)
}
inline ::pg_query::WithClause* Node::_internal_mutable_with_clause() {
  if (node_case() != kWithClause) {
    clear_node();
    set_has_with_clause();
    _impl_.node_.with_clause_ = CreateMaybeMessage<::pg_query::WithClause>(GetArena());
  }
  return _impl_.node_.with_clause_;
}
inline ::pg_query::WithClause* Node::mutable_with_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::WithClause* _msg = _internal_mutable_with_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.with_clause)
  return _msg;
}

// .pg_query.InferClause infer_clause = 99 [json_name = "InferClause"];
inline bool Node::has_infer_clause() const {
  return node_case() == kInferClause;
}
inline bool Node::_internal_has_infer_clause() const {
  return node_case() == kInferClause;
}
inline void Node::set_has_infer_clause() {
  _impl_._oneof_case_[0] = kInferClause;
}
inline void Node::clear_infer_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kInferClause) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kInferClause) {
    clear_has_node();
    auto* temp = _impl_.node_.infer_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.infer_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::InferClause& Node::_internal_infer_clause() const {
  return node_case() == kInferClause ? *_impl_.node_.infer_clause_ : reinterpret_cast<::pg_query::InferClause&>(::pg_query::_InferClause_default_instance_);
}
inline const ::pg_query::InferClause& Node::infer_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kInferClause) {
    clear_has_node();
    auto* temp = _impl_.node_.infer_clause_;
    _impl_.node_.infer_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_infer_clause(::pg_query::InferClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_infer_clause();
    _impl_.node_.infer_clause_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.infer_clause)
}
inline ::pg_query::InferClause* Node::_internal_mutable_infer_clause() {
  if (node_case() != kInferClause) {
    clear_node();
    set_has_infer_clause();
    _impl_.node_.infer_clause_ = CreateMaybeMessage<::pg_query::InferClause>(GetArena());
  }
  return _impl_.node_.infer_clause_;
}
inline ::pg_query::InferClause* Node::mutable_infer_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::InferClause* _msg = _internal_mutable_infer_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.infer_clause)
  return _msg;
}

// .pg_query.OnConflictClause on_conflict_clause = 100 [json_name = "OnConflictClause"];
inline bool Node::has_on_conflict_clause() const {
  return node_case() == kOnConflictClause;
}
inline bool Node::_internal_has_on_conflict_clause() const {
  return node_case() == kOnConflictClause;
}
inline void Node::set_has_on_conflict_clause() {
  _impl_._oneof_case_[0] = kOnConflictClause;
}
inline void Node::clear_on_conflict_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kOnConflictClause) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kOnConflictClause) {
    clear_has_node();
    auto* temp = _impl_.node_.on_conflict_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.on_conflict_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::OnConflictClause& Node::_internal_on_conflict_clause() const {
  return node_case() == kOnConflictClause ? *_impl_.node_.on_conflict_clause_ : reinterpret_cast<::pg_query::OnConflictClause&>(::pg_query::_OnConflictClause_default_instance_);
}
inline const ::pg_query::OnConflictClause& Node::on_conflict_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kOnConflictClause) {
    clear_has_node();
    auto* temp = _impl_.node_.on_conflict_clause_;
    _impl_.node_.on_conflict_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_on_conflict_clause(::pg_query::OnConflictClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_on_conflict_clause();
    _impl_.node_.on_conflict_clause_ = value;
  }
  // @@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 (node_case() != kOnConflictClause) {
    clear_node();
    set_has_on_conflict_clause();
    _impl_.node_.on_conflict_clause_ = CreateMaybeMessage<::pg_query::OnConflictClause>(GetArena());
  }
  return _impl_.node_.on_conflict_clause_;
}
inline ::pg_query::OnConflictClause* Node::mutable_on_conflict_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::OnConflictClause* _msg = _internal_mutable_on_conflict_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.on_conflict_clause)
  return _msg;
}

// .pg_query.CTESearchClause ctesearch_clause = 101 [json_name = "CTESearchClause"];
inline bool Node::has_ctesearch_clause() const {
  return node_case() == kCtesearchClause;
}
inline bool Node::_internal_has_ctesearch_clause() const {
  return node_case() == kCtesearchClause;
}
inline void Node::set_has_ctesearch_clause() {
  _impl_._oneof_case_[0] = kCtesearchClause;
}
inline void Node::clear_ctesearch_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCtesearchClause) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.ctesearch_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CTESearchClause* Node::release_ctesearch_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.ctesearch_clause)
  if (node_case() == kCtesearchClause) {
    clear_has_node();
    auto* temp = _impl_.node_.ctesearch_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.ctesearch_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CTESearchClause& Node::_internal_ctesearch_clause() const {
  return node_case() == kCtesearchClause ? *_impl_.node_.ctesearch_clause_ : reinterpret_cast<::pg_query::CTESearchClause&>(::pg_query::_CTESearchClause_default_instance_);
}
inline const ::pg_query::CTESearchClause& Node::ctesearch_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.ctesearch_clause)
  return _internal_ctesearch_clause();
}
inline ::pg_query::CTESearchClause* Node::unsafe_arena_release_ctesearch_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.ctesearch_clause)
  if (node_case() == kCtesearchClause) {
    clear_has_node();
    auto* temp = _impl_.node_.ctesearch_clause_;
    _impl_.node_.ctesearch_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_ctesearch_clause(::pg_query::CTESearchClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_ctesearch_clause();
    _impl_.node_.ctesearch_clause_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.ctesearch_clause)
}
inline ::pg_query::CTESearchClause* Node::_internal_mutable_ctesearch_clause() {
  if (node_case() != kCtesearchClause) {
    clear_node();
    set_has_ctesearch_clause();
    _impl_.node_.ctesearch_clause_ = CreateMaybeMessage<::pg_query::CTESearchClause>(GetArena());
  }
  return _impl_.node_.ctesearch_clause_;
}
inline ::pg_query::CTESearchClause* Node::mutable_ctesearch_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CTESearchClause* _msg = _internal_mutable_ctesearch_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.ctesearch_clause)
  return _msg;
}

// .pg_query.CTECycleClause ctecycle_clause = 102 [json_name = "CTECycleClause"];
inline bool Node::has_ctecycle_clause() const {
  return node_case() == kCtecycleClause;
}
inline bool Node::_internal_has_ctecycle_clause() const {
  return node_case() == kCtecycleClause;
}
inline void Node::set_has_ctecycle_clause() {
  _impl_._oneof_case_[0] = kCtecycleClause;
}
inline void Node::clear_ctecycle_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCtecycleClause) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.ctecycle_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::CTECycleClause* Node::release_ctecycle_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.ctecycle_clause)
  if (node_case() == kCtecycleClause) {
    clear_has_node();
    auto* temp = _impl_.node_.ctecycle_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.ctecycle_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CTECycleClause& Node::_internal_ctecycle_clause() const {
  return node_case() == kCtecycleClause ? *_impl_.node_.ctecycle_clause_ : reinterpret_cast<::pg_query::CTECycleClause&>(::pg_query::_CTECycleClause_default_instance_);
}
inline const ::pg_query::CTECycleClause& Node::ctecycle_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.ctecycle_clause)
  return _internal_ctecycle_clause();
}
inline ::pg_query::CTECycleClause* Node::unsafe_arena_release_ctecycle_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.ctecycle_clause)
  if (node_case() == kCtecycleClause) {
    clear_has_node();
    auto* temp = _impl_.node_.ctecycle_clause_;
    _impl_.node_.ctecycle_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_ctecycle_clause(::pg_query::CTECycleClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_ctecycle_clause();
    _impl_.node_.ctecycle_clause_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.ctecycle_clause)
}
inline ::pg_query::CTECycleClause* Node::_internal_mutable_ctecycle_clause() {
  if (node_case() != kCtecycleClause) {
    clear_node();
    set_has_ctecycle_clause();
    _impl_.node_.ctecycle_clause_ = CreateMaybeMessage<::pg_query::CTECycleClause>(GetArena());
  }
  return _impl_.node_.ctecycle_clause_;
}
inline ::pg_query::CTECycleClause* Node::mutable_ctecycle_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CTECycleClause* _msg = _internal_mutable_ctecycle_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.ctecycle_clause)
  return _msg;
}

// .pg_query.CommonTableExpr common_table_expr = 103 [json_name = "CommonTableExpr"];
inline bool Node::has_common_table_expr() const {
  return node_case() == kCommonTableExpr;
}
inline bool Node::_internal_has_common_table_expr() const {
  return node_case() == kCommonTableExpr;
}
inline void Node::set_has_common_table_expr() {
  _impl_._oneof_case_[0] = kCommonTableExpr;
}
inline void Node::clear_common_table_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCommonTableExpr) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCommonTableExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.common_table_expr_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.common_table_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CommonTableExpr& Node::_internal_common_table_expr() const {
  return node_case() == kCommonTableExpr ? *_impl_.node_.common_table_expr_ : reinterpret_cast<::pg_query::CommonTableExpr&>(::pg_query::_CommonTableExpr_default_instance_);
}
inline const ::pg_query::CommonTableExpr& Node::common_table_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCommonTableExpr) {
    clear_has_node();
    auto* temp = _impl_.node_.common_table_expr_;
    _impl_.node_.common_table_expr_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_common_table_expr(::pg_query::CommonTableExpr* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_common_table_expr();
    _impl_.node_.common_table_expr_ = value;
  }
  // @@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 (node_case() != kCommonTableExpr) {
    clear_node();
    set_has_common_table_expr();
    _impl_.node_.common_table_expr_ = CreateMaybeMessage<::pg_query::CommonTableExpr>(GetArena());
  }
  return _impl_.node_.common_table_expr_;
}
inline ::pg_query::CommonTableExpr* Node::mutable_common_table_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CommonTableExpr* _msg = _internal_mutable_common_table_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.common_table_expr)
  return _msg;
}

// .pg_query.MergeWhenClause merge_when_clause = 104 [json_name = "MergeWhenClause"];
inline bool Node::has_merge_when_clause() const {
  return node_case() == kMergeWhenClause;
}
inline bool Node::_internal_has_merge_when_clause() const {
  return node_case() == kMergeWhenClause;
}
inline void Node::set_has_merge_when_clause() {
  _impl_._oneof_case_[0] = kMergeWhenClause;
}
inline void Node::clear_merge_when_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kMergeWhenClause) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.merge_when_clause_;
    }
    clear_has_node();
  }
}
inline ::pg_query::MergeWhenClause* Node::release_merge_when_clause() {
  // @@protoc_insertion_point(field_release:pg_query.Node.merge_when_clause)
  if (node_case() == kMergeWhenClause) {
    clear_has_node();
    auto* temp = _impl_.node_.merge_when_clause_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.merge_when_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::MergeWhenClause& Node::_internal_merge_when_clause() const {
  return node_case() == kMergeWhenClause ? *_impl_.node_.merge_when_clause_ : reinterpret_cast<::pg_query::MergeWhenClause&>(::pg_query::_MergeWhenClause_default_instance_);
}
inline const ::pg_query::MergeWhenClause& Node::merge_when_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.merge_when_clause)
  return _internal_merge_when_clause();
}
inline ::pg_query::MergeWhenClause* Node::unsafe_arena_release_merge_when_clause() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.merge_when_clause)
  if (node_case() == kMergeWhenClause) {
    clear_has_node();
    auto* temp = _impl_.node_.merge_when_clause_;
    _impl_.node_.merge_when_clause_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_merge_when_clause(::pg_query::MergeWhenClause* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_merge_when_clause();
    _impl_.node_.merge_when_clause_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.merge_when_clause)
}
inline ::pg_query::MergeWhenClause* Node::_internal_mutable_merge_when_clause() {
  if (node_case() != kMergeWhenClause) {
    clear_node();
    set_has_merge_when_clause();
    _impl_.node_.merge_when_clause_ = CreateMaybeMessage<::pg_query::MergeWhenClause>(GetArena());
  }
  return _impl_.node_.merge_when_clause_;
}
inline ::pg_query::MergeWhenClause* Node::mutable_merge_when_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::MergeWhenClause* _msg = _internal_mutable_merge_when_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.merge_when_clause)
  return _msg;
}

// .pg_query.MergeAction merge_action = 105 [json_name = "MergeAction"];
inline bool Node::has_merge_action() const {
  return node_case() == kMergeAction;
}
inline bool Node::_internal_has_merge_action() const {
  return node_case() == kMergeAction;
}
inline void Node::set_has_merge_action() {
  _impl_._oneof_case_[0] = kMergeAction;
}
inline void Node::clear_merge_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kMergeAction) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.merge_action_;
    }
    clear_has_node();
  }
}
inline ::pg_query::MergeAction* Node::release_merge_action() {
  // @@protoc_insertion_point(field_release:pg_query.Node.merge_action)
  if (node_case() == kMergeAction) {
    clear_has_node();
    auto* temp = _impl_.node_.merge_action_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.merge_action_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::MergeAction& Node::_internal_merge_action() const {
  return node_case() == kMergeAction ? *_impl_.node_.merge_action_ : reinterpret_cast<::pg_query::MergeAction&>(::pg_query::_MergeAction_default_instance_);
}
inline const ::pg_query::MergeAction& Node::merge_action() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.merge_action)
  return _internal_merge_action();
}
inline ::pg_query::MergeAction* Node::unsafe_arena_release_merge_action() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.merge_action)
  if (node_case() == kMergeAction) {
    clear_has_node();
    auto* temp = _impl_.node_.merge_action_;
    _impl_.node_.merge_action_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_merge_action(::pg_query::MergeAction* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_merge_action();
    _impl_.node_.merge_action_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.merge_action)
}
inline ::pg_query::MergeAction* Node::_internal_mutable_merge_action() {
  if (node_case() != kMergeAction) {
    clear_node();
    set_has_merge_action();
    _impl_.node_.merge_action_ = CreateMaybeMessage<::pg_query::MergeAction>(GetArena());
  }
  return _impl_.node_.merge_action_;
}
inline ::pg_query::MergeAction* Node::mutable_merge_action() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::MergeAction* _msg = _internal_mutable_merge_action();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.merge_action)
  return _msg;
}

// .pg_query.TriggerTransition trigger_transition = 106 [json_name = "TriggerTransition"];
inline bool Node::has_trigger_transition() const {
  return node_case() == kTriggerTransition;
}
inline bool Node::_internal_has_trigger_transition() const {
  return node_case() == kTriggerTransition;
}
inline void Node::set_has_trigger_transition() {
  _impl_._oneof_case_[0] = kTriggerTransition;
}
inline void Node::clear_trigger_transition() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kTriggerTransition) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kTriggerTransition) {
    clear_has_node();
    auto* temp = _impl_.node_.trigger_transition_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.trigger_transition_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TriggerTransition& Node::_internal_trigger_transition() const {
  return node_case() == kTriggerTransition ? *_impl_.node_.trigger_transition_ : reinterpret_cast<::pg_query::TriggerTransition&>(::pg_query::_TriggerTransition_default_instance_);
}
inline const ::pg_query::TriggerTransition& Node::trigger_transition() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kTriggerTransition) {
    clear_has_node();
    auto* temp = _impl_.node_.trigger_transition_;
    _impl_.node_.trigger_transition_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_trigger_transition(::pg_query::TriggerTransition* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_trigger_transition();
    _impl_.node_.trigger_transition_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.trigger_transition)
}
inline ::pg_query::TriggerTransition* Node::_internal_mutable_trigger_transition() {
  if (node_case() != kTriggerTransition) {
    clear_node();
    set_has_trigger_transition();
    _impl_.node_.trigger_transition_ = CreateMaybeMessage<::pg_query::TriggerTransition>(GetArena());
  }
  return _impl_.node_.trigger_transition_;
}
inline ::pg_query::TriggerTransition* Node::mutable_trigger_transition() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TriggerTransition* _msg = _internal_mutable_trigger_transition();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.trigger_transition)
  return _msg;
}

// .pg_query.JsonOutput json_output = 107 [json_name = "JsonOutput"];
inline bool Node::has_json_output() const {
  return node_case() == kJsonOutput;
}
inline bool Node::_internal_has_json_output() const {
  return node_case() == kJsonOutput;
}
inline void Node::set_has_json_output() {
  _impl_._oneof_case_[0] = kJsonOutput;
}
inline void Node::clear_json_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonOutput) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_output_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonOutput* Node::release_json_output() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_output)
  if (node_case() == kJsonOutput) {
    clear_has_node();
    auto* temp = _impl_.node_.json_output_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_output_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonOutput& Node::_internal_json_output() const {
  return node_case() == kJsonOutput ? *_impl_.node_.json_output_ : reinterpret_cast<::pg_query::JsonOutput&>(::pg_query::_JsonOutput_default_instance_);
}
inline const ::pg_query::JsonOutput& Node::json_output() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_output)
  return _internal_json_output();
}
inline ::pg_query::JsonOutput* Node::unsafe_arena_release_json_output() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_output)
  if (node_case() == kJsonOutput) {
    clear_has_node();
    auto* temp = _impl_.node_.json_output_;
    _impl_.node_.json_output_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_output(::pg_query::JsonOutput* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_output();
    _impl_.node_.json_output_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_output)
}
inline ::pg_query::JsonOutput* Node::_internal_mutable_json_output() {
  if (node_case() != kJsonOutput) {
    clear_node();
    set_has_json_output();
    _impl_.node_.json_output_ = CreateMaybeMessage<::pg_query::JsonOutput>(GetArena());
  }
  return _impl_.node_.json_output_;
}
inline ::pg_query::JsonOutput* Node::mutable_json_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonOutput* _msg = _internal_mutable_json_output();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_output)
  return _msg;
}

// .pg_query.JsonKeyValue json_key_value = 108 [json_name = "JsonKeyValue"];
inline bool Node::has_json_key_value() const {
  return node_case() == kJsonKeyValue;
}
inline bool Node::_internal_has_json_key_value() const {
  return node_case() == kJsonKeyValue;
}
inline void Node::set_has_json_key_value() {
  _impl_._oneof_case_[0] = kJsonKeyValue;
}
inline void Node::clear_json_key_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonKeyValue) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_key_value_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonKeyValue* Node::release_json_key_value() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_key_value)
  if (node_case() == kJsonKeyValue) {
    clear_has_node();
    auto* temp = _impl_.node_.json_key_value_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_key_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonKeyValue& Node::_internal_json_key_value() const {
  return node_case() == kJsonKeyValue ? *_impl_.node_.json_key_value_ : reinterpret_cast<::pg_query::JsonKeyValue&>(::pg_query::_JsonKeyValue_default_instance_);
}
inline const ::pg_query::JsonKeyValue& Node::json_key_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_key_value)
  return _internal_json_key_value();
}
inline ::pg_query::JsonKeyValue* Node::unsafe_arena_release_json_key_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_key_value)
  if (node_case() == kJsonKeyValue) {
    clear_has_node();
    auto* temp = _impl_.node_.json_key_value_;
    _impl_.node_.json_key_value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_key_value(::pg_query::JsonKeyValue* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_key_value();
    _impl_.node_.json_key_value_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_key_value)
}
inline ::pg_query::JsonKeyValue* Node::_internal_mutable_json_key_value() {
  if (node_case() != kJsonKeyValue) {
    clear_node();
    set_has_json_key_value();
    _impl_.node_.json_key_value_ = CreateMaybeMessage<::pg_query::JsonKeyValue>(GetArena());
  }
  return _impl_.node_.json_key_value_;
}
inline ::pg_query::JsonKeyValue* Node::mutable_json_key_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonKeyValue* _msg = _internal_mutable_json_key_value();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_key_value)
  return _msg;
}

// .pg_query.JsonObjectConstructor json_object_constructor = 109 [json_name = "JsonObjectConstructor"];
inline bool Node::has_json_object_constructor() const {
  return node_case() == kJsonObjectConstructor;
}
inline bool Node::_internal_has_json_object_constructor() const {
  return node_case() == kJsonObjectConstructor;
}
inline void Node::set_has_json_object_constructor() {
  _impl_._oneof_case_[0] = kJsonObjectConstructor;
}
inline void Node::clear_json_object_constructor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonObjectConstructor) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_object_constructor_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonObjectConstructor* Node::release_json_object_constructor() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_object_constructor)
  if (node_case() == kJsonObjectConstructor) {
    clear_has_node();
    auto* temp = _impl_.node_.json_object_constructor_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_object_constructor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonObjectConstructor& Node::_internal_json_object_constructor() const {
  return node_case() == kJsonObjectConstructor ? *_impl_.node_.json_object_constructor_ : reinterpret_cast<::pg_query::JsonObjectConstructor&>(::pg_query::_JsonObjectConstructor_default_instance_);
}
inline const ::pg_query::JsonObjectConstructor& Node::json_object_constructor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_object_constructor)
  return _internal_json_object_constructor();
}
inline ::pg_query::JsonObjectConstructor* Node::unsafe_arena_release_json_object_constructor() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_object_constructor)
  if (node_case() == kJsonObjectConstructor) {
    clear_has_node();
    auto* temp = _impl_.node_.json_object_constructor_;
    _impl_.node_.json_object_constructor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_object_constructor(::pg_query::JsonObjectConstructor* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_object_constructor();
    _impl_.node_.json_object_constructor_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_object_constructor)
}
inline ::pg_query::JsonObjectConstructor* Node::_internal_mutable_json_object_constructor() {
  if (node_case() != kJsonObjectConstructor) {
    clear_node();
    set_has_json_object_constructor();
    _impl_.node_.json_object_constructor_ = CreateMaybeMessage<::pg_query::JsonObjectConstructor>(GetArena());
  }
  return _impl_.node_.json_object_constructor_;
}
inline ::pg_query::JsonObjectConstructor* Node::mutable_json_object_constructor() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonObjectConstructor* _msg = _internal_mutable_json_object_constructor();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_object_constructor)
  return _msg;
}

// .pg_query.JsonArrayConstructor json_array_constructor = 110 [json_name = "JsonArrayConstructor"];
inline bool Node::has_json_array_constructor() const {
  return node_case() == kJsonArrayConstructor;
}
inline bool Node::_internal_has_json_array_constructor() const {
  return node_case() == kJsonArrayConstructor;
}
inline void Node::set_has_json_array_constructor() {
  _impl_._oneof_case_[0] = kJsonArrayConstructor;
}
inline void Node::clear_json_array_constructor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonArrayConstructor) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_array_constructor_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonArrayConstructor* Node::release_json_array_constructor() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_array_constructor)
  if (node_case() == kJsonArrayConstructor) {
    clear_has_node();
    auto* temp = _impl_.node_.json_array_constructor_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_array_constructor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonArrayConstructor& Node::_internal_json_array_constructor() const {
  return node_case() == kJsonArrayConstructor ? *_impl_.node_.json_array_constructor_ : reinterpret_cast<::pg_query::JsonArrayConstructor&>(::pg_query::_JsonArrayConstructor_default_instance_);
}
inline const ::pg_query::JsonArrayConstructor& Node::json_array_constructor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_array_constructor)
  return _internal_json_array_constructor();
}
inline ::pg_query::JsonArrayConstructor* Node::unsafe_arena_release_json_array_constructor() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_array_constructor)
  if (node_case() == kJsonArrayConstructor) {
    clear_has_node();
    auto* temp = _impl_.node_.json_array_constructor_;
    _impl_.node_.json_array_constructor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_array_constructor(::pg_query::JsonArrayConstructor* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_array_constructor();
    _impl_.node_.json_array_constructor_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_array_constructor)
}
inline ::pg_query::JsonArrayConstructor* Node::_internal_mutable_json_array_constructor() {
  if (node_case() != kJsonArrayConstructor) {
    clear_node();
    set_has_json_array_constructor();
    _impl_.node_.json_array_constructor_ = CreateMaybeMessage<::pg_query::JsonArrayConstructor>(GetArena());
  }
  return _impl_.node_.json_array_constructor_;
}
inline ::pg_query::JsonArrayConstructor* Node::mutable_json_array_constructor() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonArrayConstructor* _msg = _internal_mutable_json_array_constructor();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_array_constructor)
  return _msg;
}

// .pg_query.JsonArrayQueryConstructor json_array_query_constructor = 111 [json_name = "JsonArrayQueryConstructor"];
inline bool Node::has_json_array_query_constructor() const {
  return node_case() == kJsonArrayQueryConstructor;
}
inline bool Node::_internal_has_json_array_query_constructor() const {
  return node_case() == kJsonArrayQueryConstructor;
}
inline void Node::set_has_json_array_query_constructor() {
  _impl_._oneof_case_[0] = kJsonArrayQueryConstructor;
}
inline void Node::clear_json_array_query_constructor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonArrayQueryConstructor) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_array_query_constructor_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonArrayQueryConstructor* Node::release_json_array_query_constructor() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_array_query_constructor)
  if (node_case() == kJsonArrayQueryConstructor) {
    clear_has_node();
    auto* temp = _impl_.node_.json_array_query_constructor_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_array_query_constructor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonArrayQueryConstructor& Node::_internal_json_array_query_constructor() const {
  return node_case() == kJsonArrayQueryConstructor ? *_impl_.node_.json_array_query_constructor_ : reinterpret_cast<::pg_query::JsonArrayQueryConstructor&>(::pg_query::_JsonArrayQueryConstructor_default_instance_);
}
inline const ::pg_query::JsonArrayQueryConstructor& Node::json_array_query_constructor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_array_query_constructor)
  return _internal_json_array_query_constructor();
}
inline ::pg_query::JsonArrayQueryConstructor* Node::unsafe_arena_release_json_array_query_constructor() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_array_query_constructor)
  if (node_case() == kJsonArrayQueryConstructor) {
    clear_has_node();
    auto* temp = _impl_.node_.json_array_query_constructor_;
    _impl_.node_.json_array_query_constructor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_array_query_constructor(::pg_query::JsonArrayQueryConstructor* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_array_query_constructor();
    _impl_.node_.json_array_query_constructor_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_array_query_constructor)
}
inline ::pg_query::JsonArrayQueryConstructor* Node::_internal_mutable_json_array_query_constructor() {
  if (node_case() != kJsonArrayQueryConstructor) {
    clear_node();
    set_has_json_array_query_constructor();
    _impl_.node_.json_array_query_constructor_ = CreateMaybeMessage<::pg_query::JsonArrayQueryConstructor>(GetArena());
  }
  return _impl_.node_.json_array_query_constructor_;
}
inline ::pg_query::JsonArrayQueryConstructor* Node::mutable_json_array_query_constructor() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonArrayQueryConstructor* _msg = _internal_mutable_json_array_query_constructor();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_array_query_constructor)
  return _msg;
}

// .pg_query.JsonAggConstructor json_agg_constructor = 112 [json_name = "JsonAggConstructor"];
inline bool Node::has_json_agg_constructor() const {
  return node_case() == kJsonAggConstructor;
}
inline bool Node::_internal_has_json_agg_constructor() const {
  return node_case() == kJsonAggConstructor;
}
inline void Node::set_has_json_agg_constructor() {
  _impl_._oneof_case_[0] = kJsonAggConstructor;
}
inline void Node::clear_json_agg_constructor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonAggConstructor) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_agg_constructor_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonAggConstructor* Node::release_json_agg_constructor() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_agg_constructor)
  if (node_case() == kJsonAggConstructor) {
    clear_has_node();
    auto* temp = _impl_.node_.json_agg_constructor_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_agg_constructor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonAggConstructor& Node::_internal_json_agg_constructor() const {
  return node_case() == kJsonAggConstructor ? *_impl_.node_.json_agg_constructor_ : reinterpret_cast<::pg_query::JsonAggConstructor&>(::pg_query::_JsonAggConstructor_default_instance_);
}
inline const ::pg_query::JsonAggConstructor& Node::json_agg_constructor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_agg_constructor)
  return _internal_json_agg_constructor();
}
inline ::pg_query::JsonAggConstructor* Node::unsafe_arena_release_json_agg_constructor() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_agg_constructor)
  if (node_case() == kJsonAggConstructor) {
    clear_has_node();
    auto* temp = _impl_.node_.json_agg_constructor_;
    _impl_.node_.json_agg_constructor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_agg_constructor(::pg_query::JsonAggConstructor* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_agg_constructor();
    _impl_.node_.json_agg_constructor_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_agg_constructor)
}
inline ::pg_query::JsonAggConstructor* Node::_internal_mutable_json_agg_constructor() {
  if (node_case() != kJsonAggConstructor) {
    clear_node();
    set_has_json_agg_constructor();
    _impl_.node_.json_agg_constructor_ = CreateMaybeMessage<::pg_query::JsonAggConstructor>(GetArena());
  }
  return _impl_.node_.json_agg_constructor_;
}
inline ::pg_query::JsonAggConstructor* Node::mutable_json_agg_constructor() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonAggConstructor* _msg = _internal_mutable_json_agg_constructor();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_agg_constructor)
  return _msg;
}

// .pg_query.JsonObjectAgg json_object_agg = 113 [json_name = "JsonObjectAgg"];
inline bool Node::has_json_object_agg() const {
  return node_case() == kJsonObjectAgg;
}
inline bool Node::_internal_has_json_object_agg() const {
  return node_case() == kJsonObjectAgg;
}
inline void Node::set_has_json_object_agg() {
  _impl_._oneof_case_[0] = kJsonObjectAgg;
}
inline void Node::clear_json_object_agg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonObjectAgg) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_object_agg_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonObjectAgg* Node::release_json_object_agg() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_object_agg)
  if (node_case() == kJsonObjectAgg) {
    clear_has_node();
    auto* temp = _impl_.node_.json_object_agg_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_object_agg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonObjectAgg& Node::_internal_json_object_agg() const {
  return node_case() == kJsonObjectAgg ? *_impl_.node_.json_object_agg_ : reinterpret_cast<::pg_query::JsonObjectAgg&>(::pg_query::_JsonObjectAgg_default_instance_);
}
inline const ::pg_query::JsonObjectAgg& Node::json_object_agg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_object_agg)
  return _internal_json_object_agg();
}
inline ::pg_query::JsonObjectAgg* Node::unsafe_arena_release_json_object_agg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_object_agg)
  if (node_case() == kJsonObjectAgg) {
    clear_has_node();
    auto* temp = _impl_.node_.json_object_agg_;
    _impl_.node_.json_object_agg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_object_agg(::pg_query::JsonObjectAgg* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_object_agg();
    _impl_.node_.json_object_agg_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_object_agg)
}
inline ::pg_query::JsonObjectAgg* Node::_internal_mutable_json_object_agg() {
  if (node_case() != kJsonObjectAgg) {
    clear_node();
    set_has_json_object_agg();
    _impl_.node_.json_object_agg_ = CreateMaybeMessage<::pg_query::JsonObjectAgg>(GetArena());
  }
  return _impl_.node_.json_object_agg_;
}
inline ::pg_query::JsonObjectAgg* Node::mutable_json_object_agg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonObjectAgg* _msg = _internal_mutable_json_object_agg();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_object_agg)
  return _msg;
}

// .pg_query.JsonArrayAgg json_array_agg = 114 [json_name = "JsonArrayAgg"];
inline bool Node::has_json_array_agg() const {
  return node_case() == kJsonArrayAgg;
}
inline bool Node::_internal_has_json_array_agg() const {
  return node_case() == kJsonArrayAgg;
}
inline void Node::set_has_json_array_agg() {
  _impl_._oneof_case_[0] = kJsonArrayAgg;
}
inline void Node::clear_json_array_agg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kJsonArrayAgg) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.json_array_agg_;
    }
    clear_has_node();
  }
}
inline ::pg_query::JsonArrayAgg* Node::release_json_array_agg() {
  // @@protoc_insertion_point(field_release:pg_query.Node.json_array_agg)
  if (node_case() == kJsonArrayAgg) {
    clear_has_node();
    auto* temp = _impl_.node_.json_array_agg_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.json_array_agg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::JsonArrayAgg& Node::_internal_json_array_agg() const {
  return node_case() == kJsonArrayAgg ? *_impl_.node_.json_array_agg_ : reinterpret_cast<::pg_query::JsonArrayAgg&>(::pg_query::_JsonArrayAgg_default_instance_);
}
inline const ::pg_query::JsonArrayAgg& Node::json_array_agg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.json_array_agg)
  return _internal_json_array_agg();
}
inline ::pg_query::JsonArrayAgg* Node::unsafe_arena_release_json_array_agg() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.json_array_agg)
  if (node_case() == kJsonArrayAgg) {
    clear_has_node();
    auto* temp = _impl_.node_.json_array_agg_;
    _impl_.node_.json_array_agg_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_json_array_agg(::pg_query::JsonArrayAgg* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_json_array_agg();
    _impl_.node_.json_array_agg_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.json_array_agg)
}
inline ::pg_query::JsonArrayAgg* Node::_internal_mutable_json_array_agg() {
  if (node_case() != kJsonArrayAgg) {
    clear_node();
    set_has_json_array_agg();
    _impl_.node_.json_array_agg_ = CreateMaybeMessage<::pg_query::JsonArrayAgg>(GetArena());
  }
  return _impl_.node_.json_array_agg_;
}
inline ::pg_query::JsonArrayAgg* Node::mutable_json_array_agg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonArrayAgg* _msg = _internal_mutable_json_array_agg();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.json_array_agg)
  return _msg;
}

// .pg_query.RawStmt raw_stmt = 115 [json_name = "RawStmt"];
inline bool Node::has_raw_stmt() const {
  return node_case() == kRawStmt;
}
inline bool Node::_internal_has_raw_stmt() const {
  return node_case() == kRawStmt;
}
inline void Node::set_has_raw_stmt() {
  _impl_._oneof_case_[0] = kRawStmt;
}
inline void Node::clear_raw_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRawStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRawStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.raw_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.raw_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RawStmt& Node::_internal_raw_stmt() const {
  return node_case() == kRawStmt ? *_impl_.node_.raw_stmt_ : reinterpret_cast<::pg_query::RawStmt&>(::pg_query::_RawStmt_default_instance_);
}
inline const ::pg_query::RawStmt& Node::raw_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRawStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.raw_stmt_;
    _impl_.node_.raw_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_raw_stmt(::pg_query::RawStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_raw_stmt();
    _impl_.node_.raw_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.raw_stmt)
}
inline ::pg_query::RawStmt* Node::_internal_mutable_raw_stmt() {
  if (node_case() != kRawStmt) {
    clear_node();
    set_has_raw_stmt();
    _impl_.node_.raw_stmt_ = CreateMaybeMessage<::pg_query::RawStmt>(GetArena());
  }
  return _impl_.node_.raw_stmt_;
}
inline ::pg_query::RawStmt* Node::mutable_raw_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RawStmt* _msg = _internal_mutable_raw_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.raw_stmt)
  return _msg;
}

// .pg_query.InsertStmt insert_stmt = 116 [json_name = "InsertStmt"];
inline bool Node::has_insert_stmt() const {
  return node_case() == kInsertStmt;
}
inline bool Node::_internal_has_insert_stmt() const {
  return node_case() == kInsertStmt;
}
inline void Node::set_has_insert_stmt() {
  _impl_._oneof_case_[0] = kInsertStmt;
}
inline void Node::clear_insert_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kInsertStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kInsertStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.insert_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.insert_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::InsertStmt& Node::_internal_insert_stmt() const {
  return node_case() == kInsertStmt ? *_impl_.node_.insert_stmt_ : reinterpret_cast<::pg_query::InsertStmt&>(::pg_query::_InsertStmt_default_instance_);
}
inline const ::pg_query::InsertStmt& Node::insert_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kInsertStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.insert_stmt_;
    _impl_.node_.insert_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_insert_stmt(::pg_query::InsertStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_insert_stmt();
    _impl_.node_.insert_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.insert_stmt)
}
inline ::pg_query::InsertStmt* Node::_internal_mutable_insert_stmt() {
  if (node_case() != kInsertStmt) {
    clear_node();
    set_has_insert_stmt();
    _impl_.node_.insert_stmt_ = CreateMaybeMessage<::pg_query::InsertStmt>(GetArena());
  }
  return _impl_.node_.insert_stmt_;
}
inline ::pg_query::InsertStmt* Node::mutable_insert_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::InsertStmt* _msg = _internal_mutable_insert_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.insert_stmt)
  return _msg;
}

// .pg_query.DeleteStmt delete_stmt = 117 [json_name = "DeleteStmt"];
inline bool Node::has_delete_stmt() const {
  return node_case() == kDeleteStmt;
}
inline bool Node::_internal_has_delete_stmt() const {
  return node_case() == kDeleteStmt;
}
inline void Node::set_has_delete_stmt() {
  _impl_._oneof_case_[0] = kDeleteStmt;
}
inline void Node::clear_delete_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDeleteStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDeleteStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.delete_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.delete_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DeleteStmt& Node::_internal_delete_stmt() const {
  return node_case() == kDeleteStmt ? *_impl_.node_.delete_stmt_ : reinterpret_cast<::pg_query::DeleteStmt&>(::pg_query::_DeleteStmt_default_instance_);
}
inline const ::pg_query::DeleteStmt& Node::delete_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDeleteStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.delete_stmt_;
    _impl_.node_.delete_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_delete_stmt(::pg_query::DeleteStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_delete_stmt();
    _impl_.node_.delete_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.delete_stmt)
}
inline ::pg_query::DeleteStmt* Node::_internal_mutable_delete_stmt() {
  if (node_case() != kDeleteStmt) {
    clear_node();
    set_has_delete_stmt();
    _impl_.node_.delete_stmt_ = CreateMaybeMessage<::pg_query::DeleteStmt>(GetArena());
  }
  return _impl_.node_.delete_stmt_;
}
inline ::pg_query::DeleteStmt* Node::mutable_delete_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DeleteStmt* _msg = _internal_mutable_delete_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.delete_stmt)
  return _msg;
}

// .pg_query.UpdateStmt update_stmt = 118 [json_name = "UpdateStmt"];
inline bool Node::has_update_stmt() const {
  return node_case() == kUpdateStmt;
}
inline bool Node::_internal_has_update_stmt() const {
  return node_case() == kUpdateStmt;
}
inline void Node::set_has_update_stmt() {
  _impl_._oneof_case_[0] = kUpdateStmt;
}
inline void Node::clear_update_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kUpdateStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kUpdateStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.update_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.update_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::UpdateStmt& Node::_internal_update_stmt() const {
  return node_case() == kUpdateStmt ? *_impl_.node_.update_stmt_ : reinterpret_cast<::pg_query::UpdateStmt&>(::pg_query::_UpdateStmt_default_instance_);
}
inline const ::pg_query::UpdateStmt& Node::update_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kUpdateStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.update_stmt_;
    _impl_.node_.update_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_update_stmt(::pg_query::UpdateStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_update_stmt();
    _impl_.node_.update_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.update_stmt)
}
inline ::pg_query::UpdateStmt* Node::_internal_mutable_update_stmt() {
  if (node_case() != kUpdateStmt) {
    clear_node();
    set_has_update_stmt();
    _impl_.node_.update_stmt_ = CreateMaybeMessage<::pg_query::UpdateStmt>(GetArena());
  }
  return _impl_.node_.update_stmt_;
}
inline ::pg_query::UpdateStmt* Node::mutable_update_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::UpdateStmt* _msg = _internal_mutable_update_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.update_stmt)
  return _msg;
}

// .pg_query.MergeStmt merge_stmt = 119 [json_name = "MergeStmt"];
inline bool Node::has_merge_stmt() const {
  return node_case() == kMergeStmt;
}
inline bool Node::_internal_has_merge_stmt() const {
  return node_case() == kMergeStmt;
}
inline void Node::set_has_merge_stmt() {
  _impl_._oneof_case_[0] = kMergeStmt;
}
inline void Node::clear_merge_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kMergeStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.merge_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::MergeStmt* Node::release_merge_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.merge_stmt)
  if (node_case() == kMergeStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.merge_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.merge_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::MergeStmt& Node::_internal_merge_stmt() const {
  return node_case() == kMergeStmt ? *_impl_.node_.merge_stmt_ : reinterpret_cast<::pg_query::MergeStmt&>(::pg_query::_MergeStmt_default_instance_);
}
inline const ::pg_query::MergeStmt& Node::merge_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.merge_stmt)
  return _internal_merge_stmt();
}
inline ::pg_query::MergeStmt* Node::unsafe_arena_release_merge_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.merge_stmt)
  if (node_case() == kMergeStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.merge_stmt_;
    _impl_.node_.merge_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_merge_stmt(::pg_query::MergeStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_merge_stmt();
    _impl_.node_.merge_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.merge_stmt)
}
inline ::pg_query::MergeStmt* Node::_internal_mutable_merge_stmt() {
  if (node_case() != kMergeStmt) {
    clear_node();
    set_has_merge_stmt();
    _impl_.node_.merge_stmt_ = CreateMaybeMessage<::pg_query::MergeStmt>(GetArena());
  }
  return _impl_.node_.merge_stmt_;
}
inline ::pg_query::MergeStmt* Node::mutable_merge_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::MergeStmt* _msg = _internal_mutable_merge_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.merge_stmt)
  return _msg;
}

// .pg_query.SelectStmt select_stmt = 120 [json_name = "SelectStmt"];
inline bool Node::has_select_stmt() const {
  return node_case() == kSelectStmt;
}
inline bool Node::_internal_has_select_stmt() const {
  return node_case() == kSelectStmt;
}
inline void Node::set_has_select_stmt() {
  _impl_._oneof_case_[0] = kSelectStmt;
}
inline void Node::clear_select_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kSelectStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kSelectStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.select_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.select_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SelectStmt& Node::_internal_select_stmt() const {
  return node_case() == kSelectStmt ? *_impl_.node_.select_stmt_ : reinterpret_cast<::pg_query::SelectStmt&>(::pg_query::_SelectStmt_default_instance_);
}
inline const ::pg_query::SelectStmt& Node::select_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kSelectStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.select_stmt_;
    _impl_.node_.select_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_select_stmt(::pg_query::SelectStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_select_stmt();
    _impl_.node_.select_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.select_stmt)
}
inline ::pg_query::SelectStmt* Node::_internal_mutable_select_stmt() {
  if (node_case() != kSelectStmt) {
    clear_node();
    set_has_select_stmt();
    _impl_.node_.select_stmt_ = CreateMaybeMessage<::pg_query::SelectStmt>(GetArena());
  }
  return _impl_.node_.select_stmt_;
}
inline ::pg_query::SelectStmt* Node::mutable_select_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SelectStmt* _msg = _internal_mutable_select_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.select_stmt)
  return _msg;
}

// .pg_query.SetOperationStmt set_operation_stmt = 121 [json_name = "SetOperationStmt"];
inline bool Node::has_set_operation_stmt() const {
  return node_case() == kSetOperationStmt;
}
inline bool Node::_internal_has_set_operation_stmt() const {
  return node_case() == kSetOperationStmt;
}
inline void Node::set_has_set_operation_stmt() {
  _impl_._oneof_case_[0] = kSetOperationStmt;
}
inline void Node::clear_set_operation_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kSetOperationStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kSetOperationStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.set_operation_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.set_operation_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SetOperationStmt& Node::_internal_set_operation_stmt() const {
  return node_case() == kSetOperationStmt ? *_impl_.node_.set_operation_stmt_ : reinterpret_cast<::pg_query::SetOperationStmt&>(::pg_query::_SetOperationStmt_default_instance_);
}
inline const ::pg_query::SetOperationStmt& Node::set_operation_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kSetOperationStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.set_operation_stmt_;
    _impl_.node_.set_operation_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_set_operation_stmt(::pg_query::SetOperationStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_set_operation_stmt();
    _impl_.node_.set_operation_stmt_ = value;
  }
  // @@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 (node_case() != kSetOperationStmt) {
    clear_node();
    set_has_set_operation_stmt();
    _impl_.node_.set_operation_stmt_ = CreateMaybeMessage<::pg_query::SetOperationStmt>(GetArena());
  }
  return _impl_.node_.set_operation_stmt_;
}
inline ::pg_query::SetOperationStmt* Node::mutable_set_operation_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SetOperationStmt* _msg = _internal_mutable_set_operation_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.set_operation_stmt)
  return _msg;
}

// .pg_query.ReturnStmt return_stmt = 122 [json_name = "ReturnStmt"];
inline bool Node::has_return_stmt() const {
  return node_case() == kReturnStmt;
}
inline bool Node::_internal_has_return_stmt() const {
  return node_case() == kReturnStmt;
}
inline void Node::set_has_return_stmt() {
  _impl_._oneof_case_[0] = kReturnStmt;
}
inline void Node::clear_return_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kReturnStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.return_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::ReturnStmt* Node::release_return_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.return_stmt)
  if (node_case() == kReturnStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.return_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.return_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ReturnStmt& Node::_internal_return_stmt() const {
  return node_case() == kReturnStmt ? *_impl_.node_.return_stmt_ : reinterpret_cast<::pg_query::ReturnStmt&>(::pg_query::_ReturnStmt_default_instance_);
}
inline const ::pg_query::ReturnStmt& Node::return_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.return_stmt)
  return _internal_return_stmt();
}
inline ::pg_query::ReturnStmt* Node::unsafe_arena_release_return_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.return_stmt)
  if (node_case() == kReturnStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.return_stmt_;
    _impl_.node_.return_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_return_stmt(::pg_query::ReturnStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_return_stmt();
    _impl_.node_.return_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.return_stmt)
}
inline ::pg_query::ReturnStmt* Node::_internal_mutable_return_stmt() {
  if (node_case() != kReturnStmt) {
    clear_node();
    set_has_return_stmt();
    _impl_.node_.return_stmt_ = CreateMaybeMessage<::pg_query::ReturnStmt>(GetArena());
  }
  return _impl_.node_.return_stmt_;
}
inline ::pg_query::ReturnStmt* Node::mutable_return_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ReturnStmt* _msg = _internal_mutable_return_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.return_stmt)
  return _msg;
}

// .pg_query.PLAssignStmt plassign_stmt = 123 [json_name = "PLAssignStmt"];
inline bool Node::has_plassign_stmt() const {
  return node_case() == kPlassignStmt;
}
inline bool Node::_internal_has_plassign_stmt() const {
  return node_case() == kPlassignStmt;
}
inline void Node::set_has_plassign_stmt() {
  _impl_._oneof_case_[0] = kPlassignStmt;
}
inline void Node::clear_plassign_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kPlassignStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.plassign_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::PLAssignStmt* Node::release_plassign_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.plassign_stmt)
  if (node_case() == kPlassignStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.plassign_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.plassign_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PLAssignStmt& Node::_internal_plassign_stmt() const {
  return node_case() == kPlassignStmt ? *_impl_.node_.plassign_stmt_ : reinterpret_cast<::pg_query::PLAssignStmt&>(::pg_query::_PLAssignStmt_default_instance_);
}
inline const ::pg_query::PLAssignStmt& Node::plassign_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.plassign_stmt)
  return _internal_plassign_stmt();
}
inline ::pg_query::PLAssignStmt* Node::unsafe_arena_release_plassign_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.plassign_stmt)
  if (node_case() == kPlassignStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.plassign_stmt_;
    _impl_.node_.plassign_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_plassign_stmt(::pg_query::PLAssignStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_plassign_stmt();
    _impl_.node_.plassign_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.plassign_stmt)
}
inline ::pg_query::PLAssignStmt* Node::_internal_mutable_plassign_stmt() {
  if (node_case() != kPlassignStmt) {
    clear_node();
    set_has_plassign_stmt();
    _impl_.node_.plassign_stmt_ = CreateMaybeMessage<::pg_query::PLAssignStmt>(GetArena());
  }
  return _impl_.node_.plassign_stmt_;
}
inline ::pg_query::PLAssignStmt* Node::mutable_plassign_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PLAssignStmt* _msg = _internal_mutable_plassign_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.plassign_stmt)
  return _msg;
}

// .pg_query.CreateSchemaStmt create_schema_stmt = 124 [json_name = "CreateSchemaStmt"];
inline bool Node::has_create_schema_stmt() const {
  return node_case() == kCreateSchemaStmt;
}
inline bool Node::_internal_has_create_schema_stmt() const {
  return node_case() == kCreateSchemaStmt;
}
inline void Node::set_has_create_schema_stmt() {
  _impl_._oneof_case_[0] = kCreateSchemaStmt;
}
inline void Node::clear_create_schema_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateSchemaStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateSchemaStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_schema_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_schema_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateSchemaStmt& Node::_internal_create_schema_stmt() const {
  return node_case() == kCreateSchemaStmt ? *_impl_.node_.create_schema_stmt_ : reinterpret_cast<::pg_query::CreateSchemaStmt&>(::pg_query::_CreateSchemaStmt_default_instance_);
}
inline const ::pg_query::CreateSchemaStmt& Node::create_schema_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateSchemaStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_schema_stmt_;
    _impl_.node_.create_schema_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_schema_stmt(::pg_query::CreateSchemaStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_schema_stmt();
    _impl_.node_.create_schema_stmt_ = value;
  }
  // @@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 (node_case() != kCreateSchemaStmt) {
    clear_node();
    set_has_create_schema_stmt();
    _impl_.node_.create_schema_stmt_ = CreateMaybeMessage<::pg_query::CreateSchemaStmt>(GetArena());
  }
  return _impl_.node_.create_schema_stmt_;
}
inline ::pg_query::CreateSchemaStmt* Node::mutable_create_schema_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateSchemaStmt* _msg = _internal_mutable_create_schema_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_schema_stmt)
  return _msg;
}

// .pg_query.AlterTableStmt alter_table_stmt = 125 [json_name = "AlterTableStmt"];
inline bool Node::has_alter_table_stmt() const {
  return node_case() == kAlterTableStmt;
}
inline bool Node::_internal_has_alter_table_stmt() const {
  return node_case() == kAlterTableStmt;
}
inline void Node::set_has_alter_table_stmt() {
  _impl_._oneof_case_[0] = kAlterTableStmt;
}
inline void Node::clear_alter_table_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterTableStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterTableStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_table_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_table_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterTableStmt& Node::_internal_alter_table_stmt() const {
  return node_case() == kAlterTableStmt ? *_impl_.node_.alter_table_stmt_ : reinterpret_cast<::pg_query::AlterTableStmt&>(::pg_query::_AlterTableStmt_default_instance_);
}
inline const ::pg_query::AlterTableStmt& Node::alter_table_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterTableStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_table_stmt_;
    _impl_.node_.alter_table_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_table_stmt(::pg_query::AlterTableStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_table_stmt();
    _impl_.node_.alter_table_stmt_ = value;
  }
  // @@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 (node_case() != kAlterTableStmt) {
    clear_node();
    set_has_alter_table_stmt();
    _impl_.node_.alter_table_stmt_ = CreateMaybeMessage<::pg_query::AlterTableStmt>(GetArena());
  }
  return _impl_.node_.alter_table_stmt_;
}
inline ::pg_query::AlterTableStmt* Node::mutable_alter_table_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterTableStmt* _msg = _internal_mutable_alter_table_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_table_stmt)
  return _msg;
}

// .pg_query.ReplicaIdentityStmt replica_identity_stmt = 126 [json_name = "ReplicaIdentityStmt"];
inline bool Node::has_replica_identity_stmt() const {
  return node_case() == kReplicaIdentityStmt;
}
inline bool Node::_internal_has_replica_identity_stmt() const {
  return node_case() == kReplicaIdentityStmt;
}
inline void Node::set_has_replica_identity_stmt() {
  _impl_._oneof_case_[0] = kReplicaIdentityStmt;
}
inline void Node::clear_replica_identity_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kReplicaIdentityStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kReplicaIdentityStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.replica_identity_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.replica_identity_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ReplicaIdentityStmt& Node::_internal_replica_identity_stmt() const {
  return node_case() == kReplicaIdentityStmt ? *_impl_.node_.replica_identity_stmt_ : reinterpret_cast<::pg_query::ReplicaIdentityStmt&>(::pg_query::_ReplicaIdentityStmt_default_instance_);
}
inline const ::pg_query::ReplicaIdentityStmt& Node::replica_identity_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kReplicaIdentityStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.replica_identity_stmt_;
    _impl_.node_.replica_identity_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_replica_identity_stmt(::pg_query::ReplicaIdentityStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_replica_identity_stmt();
    _impl_.node_.replica_identity_stmt_ = value;
  }
  // @@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 (node_case() != kReplicaIdentityStmt) {
    clear_node();
    set_has_replica_identity_stmt();
    _impl_.node_.replica_identity_stmt_ = CreateMaybeMessage<::pg_query::ReplicaIdentityStmt>(GetArena());
  }
  return _impl_.node_.replica_identity_stmt_;
}
inline ::pg_query::ReplicaIdentityStmt* Node::mutable_replica_identity_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ReplicaIdentityStmt* _msg = _internal_mutable_replica_identity_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.replica_identity_stmt)
  return _msg;
}

// .pg_query.AlterTableCmd alter_table_cmd = 127 [json_name = "AlterTableCmd"];
inline bool Node::has_alter_table_cmd() const {
  return node_case() == kAlterTableCmd;
}
inline bool Node::_internal_has_alter_table_cmd() const {
  return node_case() == kAlterTableCmd;
}
inline void Node::set_has_alter_table_cmd() {
  _impl_._oneof_case_[0] = kAlterTableCmd;
}
inline void Node::clear_alter_table_cmd() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterTableCmd) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterTableCmd) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_table_cmd_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_table_cmd_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterTableCmd& Node::_internal_alter_table_cmd() const {
  return node_case() == kAlterTableCmd ? *_impl_.node_.alter_table_cmd_ : reinterpret_cast<::pg_query::AlterTableCmd&>(::pg_query::_AlterTableCmd_default_instance_);
}
inline const ::pg_query::AlterTableCmd& Node::alter_table_cmd() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterTableCmd) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_table_cmd_;
    _impl_.node_.alter_table_cmd_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_table_cmd(::pg_query::AlterTableCmd* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_table_cmd();
    _impl_.node_.alter_table_cmd_ = value;
  }
  // @@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 (node_case() != kAlterTableCmd) {
    clear_node();
    set_has_alter_table_cmd();
    _impl_.node_.alter_table_cmd_ = CreateMaybeMessage<::pg_query::AlterTableCmd>(GetArena());
  }
  return _impl_.node_.alter_table_cmd_;
}
inline ::pg_query::AlterTableCmd* Node::mutable_alter_table_cmd() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterTableCmd* _msg = _internal_mutable_alter_table_cmd();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_table_cmd)
  return _msg;
}

// .pg_query.AlterCollationStmt alter_collation_stmt = 128 [json_name = "AlterCollationStmt"];
inline bool Node::has_alter_collation_stmt() const {
  return node_case() == kAlterCollationStmt;
}
inline bool Node::_internal_has_alter_collation_stmt() const {
  return node_case() == kAlterCollationStmt;
}
inline void Node::set_has_alter_collation_stmt() {
  _impl_._oneof_case_[0] = kAlterCollationStmt;
}
inline void Node::clear_alter_collation_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterCollationStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterCollationStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_collation_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_collation_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterCollationStmt& Node::_internal_alter_collation_stmt() const {
  return node_case() == kAlterCollationStmt ? *_impl_.node_.alter_collation_stmt_ : reinterpret_cast<::pg_query::AlterCollationStmt&>(::pg_query::_AlterCollationStmt_default_instance_);
}
inline const ::pg_query::AlterCollationStmt& Node::alter_collation_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterCollationStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_collation_stmt_;
    _impl_.node_.alter_collation_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_collation_stmt(::pg_query::AlterCollationStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_collation_stmt();
    _impl_.node_.alter_collation_stmt_ = value;
  }
  // @@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 (node_case() != kAlterCollationStmt) {
    clear_node();
    set_has_alter_collation_stmt();
    _impl_.node_.alter_collation_stmt_ = CreateMaybeMessage<::pg_query::AlterCollationStmt>(GetArena());
  }
  return _impl_.node_.alter_collation_stmt_;
}
inline ::pg_query::AlterCollationStmt* Node::mutable_alter_collation_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterCollationStmt* _msg = _internal_mutable_alter_collation_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_collation_stmt)
  return _msg;
}

// .pg_query.AlterDomainStmt alter_domain_stmt = 129 [json_name = "AlterDomainStmt"];
inline bool Node::has_alter_domain_stmt() const {
  return node_case() == kAlterDomainStmt;
}
inline bool Node::_internal_has_alter_domain_stmt() const {
  return node_case() == kAlterDomainStmt;
}
inline void Node::set_has_alter_domain_stmt() {
  _impl_._oneof_case_[0] = kAlterDomainStmt;
}
inline void Node::clear_alter_domain_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterDomainStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterDomainStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_domain_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_domain_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterDomainStmt& Node::_internal_alter_domain_stmt() const {
  return node_case() == kAlterDomainStmt ? *_impl_.node_.alter_domain_stmt_ : reinterpret_cast<::pg_query::AlterDomainStmt&>(::pg_query::_AlterDomainStmt_default_instance_);
}
inline const ::pg_query::AlterDomainStmt& Node::alter_domain_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterDomainStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_domain_stmt_;
    _impl_.node_.alter_domain_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_domain_stmt(::pg_query::AlterDomainStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_domain_stmt();
    _impl_.node_.alter_domain_stmt_ = value;
  }
  // @@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 (node_case() != kAlterDomainStmt) {
    clear_node();
    set_has_alter_domain_stmt();
    _impl_.node_.alter_domain_stmt_ = CreateMaybeMessage<::pg_query::AlterDomainStmt>(GetArena());
  }
  return _impl_.node_.alter_domain_stmt_;
}
inline ::pg_query::AlterDomainStmt* Node::mutable_alter_domain_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterDomainStmt* _msg = _internal_mutable_alter_domain_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_domain_stmt)
  return _msg;
}

// .pg_query.GrantStmt grant_stmt = 130 [json_name = "GrantStmt"];
inline bool Node::has_grant_stmt() const {
  return node_case() == kGrantStmt;
}
inline bool Node::_internal_has_grant_stmt() const {
  return node_case() == kGrantStmt;
}
inline void Node::set_has_grant_stmt() {
  _impl_._oneof_case_[0] = kGrantStmt;
}
inline void Node::clear_grant_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kGrantStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kGrantStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.grant_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.grant_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::GrantStmt& Node::_internal_grant_stmt() const {
  return node_case() == kGrantStmt ? *_impl_.node_.grant_stmt_ : reinterpret_cast<::pg_query::GrantStmt&>(::pg_query::_GrantStmt_default_instance_);
}
inline const ::pg_query::GrantStmt& Node::grant_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kGrantStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.grant_stmt_;
    _impl_.node_.grant_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_grant_stmt(::pg_query::GrantStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_grant_stmt();
    _impl_.node_.grant_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.grant_stmt)
}
inline ::pg_query::GrantStmt* Node::_internal_mutable_grant_stmt() {
  if (node_case() != kGrantStmt) {
    clear_node();
    set_has_grant_stmt();
    _impl_.node_.grant_stmt_ = CreateMaybeMessage<::pg_query::GrantStmt>(GetArena());
  }
  return _impl_.node_.grant_stmt_;
}
inline ::pg_query::GrantStmt* Node::mutable_grant_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::GrantStmt* _msg = _internal_mutable_grant_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.grant_stmt)
  return _msg;
}

// .pg_query.ObjectWithArgs object_with_args = 131 [json_name = "ObjectWithArgs"];
inline bool Node::has_object_with_args() const {
  return node_case() == kObjectWithArgs;
}
inline bool Node::_internal_has_object_with_args() const {
  return node_case() == kObjectWithArgs;
}
inline void Node::set_has_object_with_args() {
  _impl_._oneof_case_[0] = kObjectWithArgs;
}
inline void Node::clear_object_with_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kObjectWithArgs) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kObjectWithArgs) {
    clear_has_node();
    auto* temp = _impl_.node_.object_with_args_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.object_with_args_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ObjectWithArgs& Node::_internal_object_with_args() const {
  return node_case() == kObjectWithArgs ? *_impl_.node_.object_with_args_ : reinterpret_cast<::pg_query::ObjectWithArgs&>(::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& Node::object_with_args() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kObjectWithArgs) {
    clear_has_node();
    auto* temp = _impl_.node_.object_with_args_;
    _impl_.node_.object_with_args_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_object_with_args(::pg_query::ObjectWithArgs* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_object_with_args();
    _impl_.node_.object_with_args_ = value;
  }
  // @@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 (node_case() != kObjectWithArgs) {
    clear_node();
    set_has_object_with_args();
    _impl_.node_.object_with_args_ = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
  }
  return _impl_.node_.object_with_args_;
}
inline ::pg_query::ObjectWithArgs* Node::mutable_object_with_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ObjectWithArgs* _msg = _internal_mutable_object_with_args();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.object_with_args)
  return _msg;
}

// .pg_query.AccessPriv access_priv = 132 [json_name = "AccessPriv"];
inline bool Node::has_access_priv() const {
  return node_case() == kAccessPriv;
}
inline bool Node::_internal_has_access_priv() const {
  return node_case() == kAccessPriv;
}
inline void Node::set_has_access_priv() {
  _impl_._oneof_case_[0] = kAccessPriv;
}
inline void Node::clear_access_priv() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAccessPriv) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAccessPriv) {
    clear_has_node();
    auto* temp = _impl_.node_.access_priv_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.access_priv_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AccessPriv& Node::_internal_access_priv() const {
  return node_case() == kAccessPriv ? *_impl_.node_.access_priv_ : reinterpret_cast<::pg_query::AccessPriv&>(::pg_query::_AccessPriv_default_instance_);
}
inline const ::pg_query::AccessPriv& Node::access_priv() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAccessPriv) {
    clear_has_node();
    auto* temp = _impl_.node_.access_priv_;
    _impl_.node_.access_priv_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_access_priv(::pg_query::AccessPriv* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_access_priv();
    _impl_.node_.access_priv_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.access_priv)
}
inline ::pg_query::AccessPriv* Node::_internal_mutable_access_priv() {
  if (node_case() != kAccessPriv) {
    clear_node();
    set_has_access_priv();
    _impl_.node_.access_priv_ = CreateMaybeMessage<::pg_query::AccessPriv>(GetArena());
  }
  return _impl_.node_.access_priv_;
}
inline ::pg_query::AccessPriv* Node::mutable_access_priv() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AccessPriv* _msg = _internal_mutable_access_priv();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.access_priv)
  return _msg;
}

// .pg_query.GrantRoleStmt grant_role_stmt = 133 [json_name = "GrantRoleStmt"];
inline bool Node::has_grant_role_stmt() const {
  return node_case() == kGrantRoleStmt;
}
inline bool Node::_internal_has_grant_role_stmt() const {
  return node_case() == kGrantRoleStmt;
}
inline void Node::set_has_grant_role_stmt() {
  _impl_._oneof_case_[0] = kGrantRoleStmt;
}
inline void Node::clear_grant_role_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kGrantRoleStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kGrantRoleStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.grant_role_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.grant_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::GrantRoleStmt& Node::_internal_grant_role_stmt() const {
  return node_case() == kGrantRoleStmt ? *_impl_.node_.grant_role_stmt_ : reinterpret_cast<::pg_query::GrantRoleStmt&>(::pg_query::_GrantRoleStmt_default_instance_);
}
inline const ::pg_query::GrantRoleStmt& Node::grant_role_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kGrantRoleStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.grant_role_stmt_;
    _impl_.node_.grant_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_grant_role_stmt(::pg_query::GrantRoleStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_grant_role_stmt();
    _impl_.node_.grant_role_stmt_ = value;
  }
  // @@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 (node_case() != kGrantRoleStmt) {
    clear_node();
    set_has_grant_role_stmt();
    _impl_.node_.grant_role_stmt_ = CreateMaybeMessage<::pg_query::GrantRoleStmt>(GetArena());
  }
  return _impl_.node_.grant_role_stmt_;
}
inline ::pg_query::GrantRoleStmt* Node::mutable_grant_role_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::GrantRoleStmt* _msg = _internal_mutable_grant_role_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.grant_role_stmt)
  return _msg;
}

// .pg_query.AlterDefaultPrivilegesStmt alter_default_privileges_stmt = 134 [json_name = "AlterDefaultPrivilegesStmt"];
inline bool Node::has_alter_default_privileges_stmt() const {
  return node_case() == kAlterDefaultPrivilegesStmt;
}
inline bool Node::_internal_has_alter_default_privileges_stmt() const {
  return node_case() == kAlterDefaultPrivilegesStmt;
}
inline void Node::set_has_alter_default_privileges_stmt() {
  _impl_._oneof_case_[0] = kAlterDefaultPrivilegesStmt;
}
inline void Node::clear_alter_default_privileges_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterDefaultPrivilegesStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterDefaultPrivilegesStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_default_privileges_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_default_privileges_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterDefaultPrivilegesStmt& Node::_internal_alter_default_privileges_stmt() const {
  return node_case() == kAlterDefaultPrivilegesStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterDefaultPrivilegesStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_default_privileges_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_default_privileges_stmt();
    _impl_.node_.alter_default_privileges_stmt_ = value;
  }
  // @@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 (node_case() != kAlterDefaultPrivilegesStmt) {
    clear_node();
    set_has_alter_default_privileges_stmt();
    _impl_.node_.alter_default_privileges_stmt_ = CreateMaybeMessage<::pg_query::AlterDefaultPrivilegesStmt>(GetArena());
  }
  return _impl_.node_.alter_default_privileges_stmt_;
}
inline ::pg_query::AlterDefaultPrivilegesStmt* Node::mutable_alter_default_privileges_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterDefaultPrivilegesStmt* _msg = _internal_mutable_alter_default_privileges_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_default_privileges_stmt)
  return _msg;
}

// .pg_query.CopyStmt copy_stmt = 135 [json_name = "CopyStmt"];
inline bool Node::has_copy_stmt() const {
  return node_case() == kCopyStmt;
}
inline bool Node::_internal_has_copy_stmt() const {
  return node_case() == kCopyStmt;
}
inline void Node::set_has_copy_stmt() {
  _impl_._oneof_case_[0] = kCopyStmt;
}
inline void Node::clear_copy_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCopyStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCopyStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.copy_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.copy_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CopyStmt& Node::_internal_copy_stmt() const {
  return node_case() == kCopyStmt ? *_impl_.node_.copy_stmt_ : reinterpret_cast<::pg_query::CopyStmt&>(::pg_query::_CopyStmt_default_instance_);
}
inline const ::pg_query::CopyStmt& Node::copy_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCopyStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.copy_stmt_;
    _impl_.node_.copy_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_copy_stmt(::pg_query::CopyStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_copy_stmt();
    _impl_.node_.copy_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.copy_stmt)
}
inline ::pg_query::CopyStmt* Node::_internal_mutable_copy_stmt() {
  if (node_case() != kCopyStmt) {
    clear_node();
    set_has_copy_stmt();
    _impl_.node_.copy_stmt_ = CreateMaybeMessage<::pg_query::CopyStmt>(GetArena());
  }
  return _impl_.node_.copy_stmt_;
}
inline ::pg_query::CopyStmt* Node::mutable_copy_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CopyStmt* _msg = _internal_mutable_copy_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.copy_stmt)
  return _msg;
}

// .pg_query.VariableSetStmt variable_set_stmt = 136 [json_name = "VariableSetStmt"];
inline bool Node::has_variable_set_stmt() const {
  return node_case() == kVariableSetStmt;
}
inline bool Node::_internal_has_variable_set_stmt() const {
  return node_case() == kVariableSetStmt;
}
inline void Node::set_has_variable_set_stmt() {
  _impl_._oneof_case_[0] = kVariableSetStmt;
}
inline void Node::clear_variable_set_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kVariableSetStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kVariableSetStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.variable_set_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.variable_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::VariableSetStmt& Node::_internal_variable_set_stmt() const {
  return node_case() == kVariableSetStmt ? *_impl_.node_.variable_set_stmt_ : reinterpret_cast<::pg_query::VariableSetStmt&>(::pg_query::_VariableSetStmt_default_instance_);
}
inline const ::pg_query::VariableSetStmt& Node::variable_set_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kVariableSetStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.variable_set_stmt_;
    _impl_.node_.variable_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_variable_set_stmt(::pg_query::VariableSetStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_variable_set_stmt();
    _impl_.node_.variable_set_stmt_ = value;
  }
  // @@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 (node_case() != kVariableSetStmt) {
    clear_node();
    set_has_variable_set_stmt();
    _impl_.node_.variable_set_stmt_ = CreateMaybeMessage<::pg_query::VariableSetStmt>(GetArena());
  }
  return _impl_.node_.variable_set_stmt_;
}
inline ::pg_query::VariableSetStmt* Node::mutable_variable_set_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::VariableSetStmt* _msg = _internal_mutable_variable_set_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.variable_set_stmt)
  return _msg;
}

// .pg_query.VariableShowStmt variable_show_stmt = 137 [json_name = "VariableShowStmt"];
inline bool Node::has_variable_show_stmt() const {
  return node_case() == kVariableShowStmt;
}
inline bool Node::_internal_has_variable_show_stmt() const {
  return node_case() == kVariableShowStmt;
}
inline void Node::set_has_variable_show_stmt() {
  _impl_._oneof_case_[0] = kVariableShowStmt;
}
inline void Node::clear_variable_show_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kVariableShowStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kVariableShowStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.variable_show_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.variable_show_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::VariableShowStmt& Node::_internal_variable_show_stmt() const {
  return node_case() == kVariableShowStmt ? *_impl_.node_.variable_show_stmt_ : reinterpret_cast<::pg_query::VariableShowStmt&>(::pg_query::_VariableShowStmt_default_instance_);
}
inline const ::pg_query::VariableShowStmt& Node::variable_show_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kVariableShowStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.variable_show_stmt_;
    _impl_.node_.variable_show_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_variable_show_stmt(::pg_query::VariableShowStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_variable_show_stmt();
    _impl_.node_.variable_show_stmt_ = value;
  }
  // @@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 (node_case() != kVariableShowStmt) {
    clear_node();
    set_has_variable_show_stmt();
    _impl_.node_.variable_show_stmt_ = CreateMaybeMessage<::pg_query::VariableShowStmt>(GetArena());
  }
  return _impl_.node_.variable_show_stmt_;
}
inline ::pg_query::VariableShowStmt* Node::mutable_variable_show_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::VariableShowStmt* _msg = _internal_mutable_variable_show_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.variable_show_stmt)
  return _msg;
}

// .pg_query.CreateStmt create_stmt = 138 [json_name = "CreateStmt"];
inline bool Node::has_create_stmt() const {
  return node_case() == kCreateStmt;
}
inline bool Node::_internal_has_create_stmt() const {
  return node_case() == kCreateStmt;
}
inline void Node::set_has_create_stmt() {
  _impl_._oneof_case_[0] = kCreateStmt;
}
inline void Node::clear_create_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateStmt& Node::_internal_create_stmt() const {
  return node_case() == kCreateStmt ? *_impl_.node_.create_stmt_ : reinterpret_cast<::pg_query::CreateStmt&>(::pg_query::_CreateStmt_default_instance_);
}
inline const ::pg_query::CreateStmt& Node::create_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_stmt_;
    _impl_.node_.create_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_stmt(::pg_query::CreateStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_stmt();
    _impl_.node_.create_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_stmt)
}
inline ::pg_query::CreateStmt* Node::_internal_mutable_create_stmt() {
  if (node_case() != kCreateStmt) {
    clear_node();
    set_has_create_stmt();
    _impl_.node_.create_stmt_ = CreateMaybeMessage<::pg_query::CreateStmt>(GetArena());
  }
  return _impl_.node_.create_stmt_;
}
inline ::pg_query::CreateStmt* Node::mutable_create_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateStmt* _msg = _internal_mutable_create_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_stmt)
  return _msg;
}

// .pg_query.Constraint constraint = 139 [json_name = "Constraint"];
inline bool Node::has_constraint() const {
  return node_case() == kConstraint;
}
inline bool Node::_internal_has_constraint() const {
  return node_case() == kConstraint;
}
inline void Node::set_has_constraint() {
  _impl_._oneof_case_[0] = kConstraint;
}
inline void Node::clear_constraint() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kConstraint) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.constraint_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Constraint* Node::release_constraint() {
  // @@protoc_insertion_point(field_release:pg_query.Node.constraint)
  if (node_case() == kConstraint) {
    clear_has_node();
    auto* temp = _impl_.node_.constraint_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Constraint& Node::_internal_constraint() const {
  return node_case() == kConstraint ? *_impl_.node_.constraint_ : reinterpret_cast<::pg_query::Constraint&>(::pg_query::_Constraint_default_instance_);
}
inline const ::pg_query::Constraint& Node::constraint() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kConstraint) {
    clear_has_node();
    auto* temp = _impl_.node_.constraint_;
    _impl_.node_.constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_constraint(::pg_query::Constraint* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_constraint();
    _impl_.node_.constraint_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.constraint)
}
inline ::pg_query::Constraint* Node::_internal_mutable_constraint() {
  if (node_case() != kConstraint) {
    clear_node();
    set_has_constraint();
    _impl_.node_.constraint_ = CreateMaybeMessage<::pg_query::Constraint>(GetArena());
  }
  return _impl_.node_.constraint_;
}
inline ::pg_query::Constraint* Node::mutable_constraint() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Constraint* _msg = _internal_mutable_constraint();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.constraint)
  return _msg;
}

// .pg_query.CreateTableSpaceStmt create_table_space_stmt = 140 [json_name = "CreateTableSpaceStmt"];
inline bool Node::has_create_table_space_stmt() const {
  return node_case() == kCreateTableSpaceStmt;
}
inline bool Node::_internal_has_create_table_space_stmt() const {
  return node_case() == kCreateTableSpaceStmt;
}
inline void Node::set_has_create_table_space_stmt() {
  _impl_._oneof_case_[0] = kCreateTableSpaceStmt;
}
inline void Node::clear_create_table_space_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateTableSpaceStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateTableSpaceStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_table_space_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_table_space_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateTableSpaceStmt& Node::_internal_create_table_space_stmt() const {
  return node_case() == kCreateTableSpaceStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateTableSpaceStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_table_space_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_table_space_stmt();
    _impl_.node_.create_table_space_stmt_ = value;
  }
  // @@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 (node_case() != kCreateTableSpaceStmt) {
    clear_node();
    set_has_create_table_space_stmt();
    _impl_.node_.create_table_space_stmt_ = CreateMaybeMessage<::pg_query::CreateTableSpaceStmt>(GetArena());
  }
  return _impl_.node_.create_table_space_stmt_;
}
inline ::pg_query::CreateTableSpaceStmt* Node::mutable_create_table_space_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateTableSpaceStmt* _msg = _internal_mutable_create_table_space_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_table_space_stmt)
  return _msg;
}

// .pg_query.DropTableSpaceStmt drop_table_space_stmt = 141 [json_name = "DropTableSpaceStmt"];
inline bool Node::has_drop_table_space_stmt() const {
  return node_case() == kDropTableSpaceStmt;
}
inline bool Node::_internal_has_drop_table_space_stmt() const {
  return node_case() == kDropTableSpaceStmt;
}
inline void Node::set_has_drop_table_space_stmt() {
  _impl_._oneof_case_[0] = kDropTableSpaceStmt;
}
inline void Node::clear_drop_table_space_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDropTableSpaceStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDropTableSpaceStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.drop_table_space_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.drop_table_space_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropTableSpaceStmt& Node::_internal_drop_table_space_stmt() const {
  return node_case() == kDropTableSpaceStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDropTableSpaceStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.drop_table_space_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_drop_table_space_stmt();
    _impl_.node_.drop_table_space_stmt_ = value;
  }
  // @@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 (node_case() != kDropTableSpaceStmt) {
    clear_node();
    set_has_drop_table_space_stmt();
    _impl_.node_.drop_table_space_stmt_ = CreateMaybeMessage<::pg_query::DropTableSpaceStmt>(GetArena());
  }
  return _impl_.node_.drop_table_space_stmt_;
}
inline ::pg_query::DropTableSpaceStmt* Node::mutable_drop_table_space_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DropTableSpaceStmt* _msg = _internal_mutable_drop_table_space_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_table_space_stmt)
  return _msg;
}

// .pg_query.AlterTableSpaceOptionsStmt alter_table_space_options_stmt = 142 [json_name = "AlterTableSpaceOptionsStmt"];
inline bool Node::has_alter_table_space_options_stmt() const {
  return node_case() == kAlterTableSpaceOptionsStmt;
}
inline bool Node::_internal_has_alter_table_space_options_stmt() const {
  return node_case() == kAlterTableSpaceOptionsStmt;
}
inline void Node::set_has_alter_table_space_options_stmt() {
  _impl_._oneof_case_[0] = kAlterTableSpaceOptionsStmt;
}
inline void Node::clear_alter_table_space_options_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterTableSpaceOptionsStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterTableSpaceOptionsStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_table_space_options_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.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 node_case() == kAlterTableSpaceOptionsStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterTableSpaceOptionsStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_table_space_options_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_table_space_options_stmt();
    _impl_.node_.alter_table_space_options_stmt_ = value;
  }
  // @@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 (node_case() != kAlterTableSpaceOptionsStmt) {
    clear_node();
    set_has_alter_table_space_options_stmt();
    _impl_.node_.alter_table_space_options_stmt_ = CreateMaybeMessage<::pg_query::AlterTableSpaceOptionsStmt>(GetArena());
  }
  return _impl_.node_.alter_table_space_options_stmt_;
}
inline ::pg_query::AlterTableSpaceOptionsStmt* Node::mutable_alter_table_space_options_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterTableSpaceOptionsStmt* _msg = _internal_mutable_alter_table_space_options_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_table_space_options_stmt)
  return _msg;
}

// .pg_query.AlterTableMoveAllStmt alter_table_move_all_stmt = 143 [json_name = "AlterTableMoveAllStmt"];
inline bool Node::has_alter_table_move_all_stmt() const {
  return node_case() == kAlterTableMoveAllStmt;
}
inline bool Node::_internal_has_alter_table_move_all_stmt() const {
  return node_case() == kAlterTableMoveAllStmt;
}
inline void Node::set_has_alter_table_move_all_stmt() {
  _impl_._oneof_case_[0] = kAlterTableMoveAllStmt;
}
inline void Node::clear_alter_table_move_all_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterTableMoveAllStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterTableMoveAllStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_table_move_all_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.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 node_case() == kAlterTableMoveAllStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterTableMoveAllStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_table_move_all_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_table_move_all_stmt();
    _impl_.node_.alter_table_move_all_stmt_ = value;
  }
  // @@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 (node_case() != kAlterTableMoveAllStmt) {
    clear_node();
    set_has_alter_table_move_all_stmt();
    _impl_.node_.alter_table_move_all_stmt_ = CreateMaybeMessage<::pg_query::AlterTableMoveAllStmt>(GetArena());
  }
  return _impl_.node_.alter_table_move_all_stmt_;
}
inline ::pg_query::AlterTableMoveAllStmt* Node::mutable_alter_table_move_all_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterTableMoveAllStmt* _msg = _internal_mutable_alter_table_move_all_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_table_move_all_stmt)
  return _msg;
}

// .pg_query.CreateExtensionStmt create_extension_stmt = 144 [json_name = "CreateExtensionStmt"];
inline bool Node::has_create_extension_stmt() const {
  return node_case() == kCreateExtensionStmt;
}
inline bool Node::_internal_has_create_extension_stmt() const {
  return node_case() == kCreateExtensionStmt;
}
inline void Node::set_has_create_extension_stmt() {
  _impl_._oneof_case_[0] = kCreateExtensionStmt;
}
inline void Node::clear_create_extension_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateExtensionStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateExtensionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_extension_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_extension_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateExtensionStmt& Node::_internal_create_extension_stmt() const {
  return node_case() == kCreateExtensionStmt ? *_impl_.node_.create_extension_stmt_ : reinterpret_cast<::pg_query::CreateExtensionStmt&>(::pg_query::_CreateExtensionStmt_default_instance_);
}
inline const ::pg_query::CreateExtensionStmt& Node::create_extension_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateExtensionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_extension_stmt_;
    _impl_.node_.create_extension_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_extension_stmt(::pg_query::CreateExtensionStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_extension_stmt();
    _impl_.node_.create_extension_stmt_ = value;
  }
  // @@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 (node_case() != kCreateExtensionStmt) {
    clear_node();
    set_has_create_extension_stmt();
    _impl_.node_.create_extension_stmt_ = CreateMaybeMessage<::pg_query::CreateExtensionStmt>(GetArena());
  }
  return _impl_.node_.create_extension_stmt_;
}
inline ::pg_query::CreateExtensionStmt* Node::mutable_create_extension_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateExtensionStmt* _msg = _internal_mutable_create_extension_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_extension_stmt)
  return _msg;
}

// .pg_query.AlterExtensionStmt alter_extension_stmt = 145 [json_name = "AlterExtensionStmt"];
inline bool Node::has_alter_extension_stmt() const {
  return node_case() == kAlterExtensionStmt;
}
inline bool Node::_internal_has_alter_extension_stmt() const {
  return node_case() == kAlterExtensionStmt;
}
inline void Node::set_has_alter_extension_stmt() {
  _impl_._oneof_case_[0] = kAlterExtensionStmt;
}
inline void Node::clear_alter_extension_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterExtensionStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterExtensionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_extension_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_extension_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterExtensionStmt& Node::_internal_alter_extension_stmt() const {
  return node_case() == kAlterExtensionStmt ? *_impl_.node_.alter_extension_stmt_ : reinterpret_cast<::pg_query::AlterExtensionStmt&>(::pg_query::_AlterExtensionStmt_default_instance_);
}
inline const ::pg_query::AlterExtensionStmt& Node::alter_extension_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterExtensionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_extension_stmt_;
    _impl_.node_.alter_extension_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_extension_stmt(::pg_query::AlterExtensionStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_extension_stmt();
    _impl_.node_.alter_extension_stmt_ = value;
  }
  // @@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 (node_case() != kAlterExtensionStmt) {
    clear_node();
    set_has_alter_extension_stmt();
    _impl_.node_.alter_extension_stmt_ = CreateMaybeMessage<::pg_query::AlterExtensionStmt>(GetArena());
  }
  return _impl_.node_.alter_extension_stmt_;
}
inline ::pg_query::AlterExtensionStmt* Node::mutable_alter_extension_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterExtensionStmt* _msg = _internal_mutable_alter_extension_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_extension_stmt)
  return _msg;
}

// .pg_query.AlterExtensionContentsStmt alter_extension_contents_stmt = 146 [json_name = "AlterExtensionContentsStmt"];
inline bool Node::has_alter_extension_contents_stmt() const {
  return node_case() == kAlterExtensionContentsStmt;
}
inline bool Node::_internal_has_alter_extension_contents_stmt() const {
  return node_case() == kAlterExtensionContentsStmt;
}
inline void Node::set_has_alter_extension_contents_stmt() {
  _impl_._oneof_case_[0] = kAlterExtensionContentsStmt;
}
inline void Node::clear_alter_extension_contents_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterExtensionContentsStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterExtensionContentsStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_extension_contents_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_extension_contents_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterExtensionContentsStmt& Node::_internal_alter_extension_contents_stmt() const {
  return node_case() == kAlterExtensionContentsStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterExtensionContentsStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_extension_contents_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_extension_contents_stmt();
    _impl_.node_.alter_extension_contents_stmt_ = value;
  }
  // @@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 (node_case() != kAlterExtensionContentsStmt) {
    clear_node();
    set_has_alter_extension_contents_stmt();
    _impl_.node_.alter_extension_contents_stmt_ = CreateMaybeMessage<::pg_query::AlterExtensionContentsStmt>(GetArena());
  }
  return _impl_.node_.alter_extension_contents_stmt_;
}
inline ::pg_query::AlterExtensionContentsStmt* Node::mutable_alter_extension_contents_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterExtensionContentsStmt* _msg = _internal_mutable_alter_extension_contents_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_extension_contents_stmt)
  return _msg;
}

// .pg_query.CreateFdwStmt create_fdw_stmt = 147 [json_name = "CreateFdwStmt"];
inline bool Node::has_create_fdw_stmt() const {
  return node_case() == kCreateFdwStmt;
}
inline bool Node::_internal_has_create_fdw_stmt() const {
  return node_case() == kCreateFdwStmt;
}
inline void Node::set_has_create_fdw_stmt() {
  _impl_._oneof_case_[0] = kCreateFdwStmt;
}
inline void Node::clear_create_fdw_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateFdwStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateFdwStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_fdw_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_fdw_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateFdwStmt& Node::_internal_create_fdw_stmt() const {
  return node_case() == kCreateFdwStmt ? *_impl_.node_.create_fdw_stmt_ : reinterpret_cast<::pg_query::CreateFdwStmt&>(::pg_query::_CreateFdwStmt_default_instance_);
}
inline const ::pg_query::CreateFdwStmt& Node::create_fdw_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateFdwStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_fdw_stmt_;
    _impl_.node_.create_fdw_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_fdw_stmt(::pg_query::CreateFdwStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_fdw_stmt();
    _impl_.node_.create_fdw_stmt_ = value;
  }
  // @@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 (node_case() != kCreateFdwStmt) {
    clear_node();
    set_has_create_fdw_stmt();
    _impl_.node_.create_fdw_stmt_ = CreateMaybeMessage<::pg_query::CreateFdwStmt>(GetArena());
  }
  return _impl_.node_.create_fdw_stmt_;
}
inline ::pg_query::CreateFdwStmt* Node::mutable_create_fdw_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateFdwStmt* _msg = _internal_mutable_create_fdw_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_fdw_stmt)
  return _msg;
}

// .pg_query.AlterFdwStmt alter_fdw_stmt = 148 [json_name = "AlterFdwStmt"];
inline bool Node::has_alter_fdw_stmt() const {
  return node_case() == kAlterFdwStmt;
}
inline bool Node::_internal_has_alter_fdw_stmt() const {
  return node_case() == kAlterFdwStmt;
}
inline void Node::set_has_alter_fdw_stmt() {
  _impl_._oneof_case_[0] = kAlterFdwStmt;
}
inline void Node::clear_alter_fdw_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterFdwStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterFdwStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_fdw_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_fdw_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterFdwStmt& Node::_internal_alter_fdw_stmt() const {
  return node_case() == kAlterFdwStmt ? *_impl_.node_.alter_fdw_stmt_ : reinterpret_cast<::pg_query::AlterFdwStmt&>(::pg_query::_AlterFdwStmt_default_instance_);
}
inline const ::pg_query::AlterFdwStmt& Node::alter_fdw_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterFdwStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_fdw_stmt_;
    _impl_.node_.alter_fdw_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_fdw_stmt(::pg_query::AlterFdwStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_fdw_stmt();
    _impl_.node_.alter_fdw_stmt_ = value;
  }
  // @@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 (node_case() != kAlterFdwStmt) {
    clear_node();
    set_has_alter_fdw_stmt();
    _impl_.node_.alter_fdw_stmt_ = CreateMaybeMessage<::pg_query::AlterFdwStmt>(GetArena());
  }
  return _impl_.node_.alter_fdw_stmt_;
}
inline ::pg_query::AlterFdwStmt* Node::mutable_alter_fdw_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterFdwStmt* _msg = _internal_mutable_alter_fdw_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_fdw_stmt)
  return _msg;
}

// .pg_query.CreateForeignServerStmt create_foreign_server_stmt = 149 [json_name = "CreateForeignServerStmt"];
inline bool Node::has_create_foreign_server_stmt() const {
  return node_case() == kCreateForeignServerStmt;
}
inline bool Node::_internal_has_create_foreign_server_stmt() const {
  return node_case() == kCreateForeignServerStmt;
}
inline void Node::set_has_create_foreign_server_stmt() {
  _impl_._oneof_case_[0] = kCreateForeignServerStmt;
}
inline void Node::clear_create_foreign_server_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateForeignServerStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateForeignServerStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_foreign_server_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_foreign_server_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateForeignServerStmt& Node::_internal_create_foreign_server_stmt() const {
  return node_case() == kCreateForeignServerStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateForeignServerStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_foreign_server_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_foreign_server_stmt();
    _impl_.node_.create_foreign_server_stmt_ = value;
  }
  // @@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 (node_case() != kCreateForeignServerStmt) {
    clear_node();
    set_has_create_foreign_server_stmt();
    _impl_.node_.create_foreign_server_stmt_ = CreateMaybeMessage<::pg_query::CreateForeignServerStmt>(GetArena());
  }
  return _impl_.node_.create_foreign_server_stmt_;
}
inline ::pg_query::CreateForeignServerStmt* Node::mutable_create_foreign_server_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateForeignServerStmt* _msg = _internal_mutable_create_foreign_server_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_foreign_server_stmt)
  return _msg;
}

// .pg_query.AlterForeignServerStmt alter_foreign_server_stmt = 150 [json_name = "AlterForeignServerStmt"];
inline bool Node::has_alter_foreign_server_stmt() const {
  return node_case() == kAlterForeignServerStmt;
}
inline bool Node::_internal_has_alter_foreign_server_stmt() const {
  return node_case() == kAlterForeignServerStmt;
}
inline void Node::set_has_alter_foreign_server_stmt() {
  _impl_._oneof_case_[0] = kAlterForeignServerStmt;
}
inline void Node::clear_alter_foreign_server_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterForeignServerStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterForeignServerStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_foreign_server_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_foreign_server_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterForeignServerStmt& Node::_internal_alter_foreign_server_stmt() const {
  return node_case() == kAlterForeignServerStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterForeignServerStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_foreign_server_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_foreign_server_stmt();
    _impl_.node_.alter_foreign_server_stmt_ = value;
  }
  // @@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 (node_case() != kAlterForeignServerStmt) {
    clear_node();
    set_has_alter_foreign_server_stmt();
    _impl_.node_.alter_foreign_server_stmt_ = CreateMaybeMessage<::pg_query::AlterForeignServerStmt>(GetArena());
  }
  return _impl_.node_.alter_foreign_server_stmt_;
}
inline ::pg_query::AlterForeignServerStmt* Node::mutable_alter_foreign_server_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterForeignServerStmt* _msg = _internal_mutable_alter_foreign_server_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_foreign_server_stmt)
  return _msg;
}

// .pg_query.CreateForeignTableStmt create_foreign_table_stmt = 151 [json_name = "CreateForeignTableStmt"];
inline bool Node::has_create_foreign_table_stmt() const {
  return node_case() == kCreateForeignTableStmt;
}
inline bool Node::_internal_has_create_foreign_table_stmt() const {
  return node_case() == kCreateForeignTableStmt;
}
inline void Node::set_has_create_foreign_table_stmt() {
  _impl_._oneof_case_[0] = kCreateForeignTableStmt;
}
inline void Node::clear_create_foreign_table_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateForeignTableStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateForeignTableStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_foreign_table_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_foreign_table_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateForeignTableStmt& Node::_internal_create_foreign_table_stmt() const {
  return node_case() == kCreateForeignTableStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateForeignTableStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_foreign_table_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_foreign_table_stmt();
    _impl_.node_.create_foreign_table_stmt_ = value;
  }
  // @@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 (node_case() != kCreateForeignTableStmt) {
    clear_node();
    set_has_create_foreign_table_stmt();
    _impl_.node_.create_foreign_table_stmt_ = CreateMaybeMessage<::pg_query::CreateForeignTableStmt>(GetArena());
  }
  return _impl_.node_.create_foreign_table_stmt_;
}
inline ::pg_query::CreateForeignTableStmt* Node::mutable_create_foreign_table_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateForeignTableStmt* _msg = _internal_mutable_create_foreign_table_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_foreign_table_stmt)
  return _msg;
}

// .pg_query.CreateUserMappingStmt create_user_mapping_stmt = 152 [json_name = "CreateUserMappingStmt"];
inline bool Node::has_create_user_mapping_stmt() const {
  return node_case() == kCreateUserMappingStmt;
}
inline bool Node::_internal_has_create_user_mapping_stmt() const {
  return node_case() == kCreateUserMappingStmt;
}
inline void Node::set_has_create_user_mapping_stmt() {
  _impl_._oneof_case_[0] = kCreateUserMappingStmt;
}
inline void Node::clear_create_user_mapping_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateUserMappingStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateUserMappingStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_user_mapping_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_user_mapping_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateUserMappingStmt& Node::_internal_create_user_mapping_stmt() const {
  return node_case() == kCreateUserMappingStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateUserMappingStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_user_mapping_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_user_mapping_stmt();
    _impl_.node_.create_user_mapping_stmt_ = value;
  }
  // @@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 (node_case() != kCreateUserMappingStmt) {
    clear_node();
    set_has_create_user_mapping_stmt();
    _impl_.node_.create_user_mapping_stmt_ = CreateMaybeMessage<::pg_query::CreateUserMappingStmt>(GetArena());
  }
  return _impl_.node_.create_user_mapping_stmt_;
}
inline ::pg_query::CreateUserMappingStmt* Node::mutable_create_user_mapping_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateUserMappingStmt* _msg = _internal_mutable_create_user_mapping_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_user_mapping_stmt)
  return _msg;
}

// .pg_query.AlterUserMappingStmt alter_user_mapping_stmt = 153 [json_name = "AlterUserMappingStmt"];
inline bool Node::has_alter_user_mapping_stmt() const {
  return node_case() == kAlterUserMappingStmt;
}
inline bool Node::_internal_has_alter_user_mapping_stmt() const {
  return node_case() == kAlterUserMappingStmt;
}
inline void Node::set_has_alter_user_mapping_stmt() {
  _impl_._oneof_case_[0] = kAlterUserMappingStmt;
}
inline void Node::clear_alter_user_mapping_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterUserMappingStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterUserMappingStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_user_mapping_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_user_mapping_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterUserMappingStmt& Node::_internal_alter_user_mapping_stmt() const {
  return node_case() == kAlterUserMappingStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterUserMappingStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_user_mapping_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_user_mapping_stmt();
    _impl_.node_.alter_user_mapping_stmt_ = value;
  }
  // @@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 (node_case() != kAlterUserMappingStmt) {
    clear_node();
    set_has_alter_user_mapping_stmt();
    _impl_.node_.alter_user_mapping_stmt_ = CreateMaybeMessage<::pg_query::AlterUserMappingStmt>(GetArena());
  }
  return _impl_.node_.alter_user_mapping_stmt_;
}
inline ::pg_query::AlterUserMappingStmt* Node::mutable_alter_user_mapping_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterUserMappingStmt* _msg = _internal_mutable_alter_user_mapping_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_user_mapping_stmt)
  return _msg;
}

// .pg_query.DropUserMappingStmt drop_user_mapping_stmt = 154 [json_name = "DropUserMappingStmt"];
inline bool Node::has_drop_user_mapping_stmt() const {
  return node_case() == kDropUserMappingStmt;
}
inline bool Node::_internal_has_drop_user_mapping_stmt() const {
  return node_case() == kDropUserMappingStmt;
}
inline void Node::set_has_drop_user_mapping_stmt() {
  _impl_._oneof_case_[0] = kDropUserMappingStmt;
}
inline void Node::clear_drop_user_mapping_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDropUserMappingStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDropUserMappingStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.drop_user_mapping_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.drop_user_mapping_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropUserMappingStmt& Node::_internal_drop_user_mapping_stmt() const {
  return node_case() == kDropUserMappingStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDropUserMappingStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.drop_user_mapping_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_drop_user_mapping_stmt();
    _impl_.node_.drop_user_mapping_stmt_ = value;
  }
  // @@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 (node_case() != kDropUserMappingStmt) {
    clear_node();
    set_has_drop_user_mapping_stmt();
    _impl_.node_.drop_user_mapping_stmt_ = CreateMaybeMessage<::pg_query::DropUserMappingStmt>(GetArena());
  }
  return _impl_.node_.drop_user_mapping_stmt_;
}
inline ::pg_query::DropUserMappingStmt* Node::mutable_drop_user_mapping_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DropUserMappingStmt* _msg = _internal_mutable_drop_user_mapping_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_user_mapping_stmt)
  return _msg;
}

// .pg_query.ImportForeignSchemaStmt import_foreign_schema_stmt = 155 [json_name = "ImportForeignSchemaStmt"];
inline bool Node::has_import_foreign_schema_stmt() const {
  return node_case() == kImportForeignSchemaStmt;
}
inline bool Node::_internal_has_import_foreign_schema_stmt() const {
  return node_case() == kImportForeignSchemaStmt;
}
inline void Node::set_has_import_foreign_schema_stmt() {
  _impl_._oneof_case_[0] = kImportForeignSchemaStmt;
}
inline void Node::clear_import_foreign_schema_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kImportForeignSchemaStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kImportForeignSchemaStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.import_foreign_schema_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.import_foreign_schema_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ImportForeignSchemaStmt& Node::_internal_import_foreign_schema_stmt() const {
  return node_case() == kImportForeignSchemaStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kImportForeignSchemaStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.import_foreign_schema_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_import_foreign_schema_stmt();
    _impl_.node_.import_foreign_schema_stmt_ = value;
  }
  // @@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 (node_case() != kImportForeignSchemaStmt) {
    clear_node();
    set_has_import_foreign_schema_stmt();
    _impl_.node_.import_foreign_schema_stmt_ = CreateMaybeMessage<::pg_query::ImportForeignSchemaStmt>(GetArena());
  }
  return _impl_.node_.import_foreign_schema_stmt_;
}
inline ::pg_query::ImportForeignSchemaStmt* Node::mutable_import_foreign_schema_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ImportForeignSchemaStmt* _msg = _internal_mutable_import_foreign_schema_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.import_foreign_schema_stmt)
  return _msg;
}

// .pg_query.CreatePolicyStmt create_policy_stmt = 156 [json_name = "CreatePolicyStmt"];
inline bool Node::has_create_policy_stmt() const {
  return node_case() == kCreatePolicyStmt;
}
inline bool Node::_internal_has_create_policy_stmt() const {
  return node_case() == kCreatePolicyStmt;
}
inline void Node::set_has_create_policy_stmt() {
  _impl_._oneof_case_[0] = kCreatePolicyStmt;
}
inline void Node::clear_create_policy_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreatePolicyStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreatePolicyStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_policy_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_policy_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreatePolicyStmt& Node::_internal_create_policy_stmt() const {
  return node_case() == kCreatePolicyStmt ? *_impl_.node_.create_policy_stmt_ : reinterpret_cast<::pg_query::CreatePolicyStmt&>(::pg_query::_CreatePolicyStmt_default_instance_);
}
inline const ::pg_query::CreatePolicyStmt& Node::create_policy_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreatePolicyStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_policy_stmt_;
    _impl_.node_.create_policy_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_policy_stmt(::pg_query::CreatePolicyStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_policy_stmt();
    _impl_.node_.create_policy_stmt_ = value;
  }
  // @@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 (node_case() != kCreatePolicyStmt) {
    clear_node();
    set_has_create_policy_stmt();
    _impl_.node_.create_policy_stmt_ = CreateMaybeMessage<::pg_query::CreatePolicyStmt>(GetArena());
  }
  return _impl_.node_.create_policy_stmt_;
}
inline ::pg_query::CreatePolicyStmt* Node::mutable_create_policy_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreatePolicyStmt* _msg = _internal_mutable_create_policy_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_policy_stmt)
  return _msg;
}

// .pg_query.AlterPolicyStmt alter_policy_stmt = 157 [json_name = "AlterPolicyStmt"];
inline bool Node::has_alter_policy_stmt() const {
  return node_case() == kAlterPolicyStmt;
}
inline bool Node::_internal_has_alter_policy_stmt() const {
  return node_case() == kAlterPolicyStmt;
}
inline void Node::set_has_alter_policy_stmt() {
  _impl_._oneof_case_[0] = kAlterPolicyStmt;
}
inline void Node::clear_alter_policy_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterPolicyStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterPolicyStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_policy_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_policy_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterPolicyStmt& Node::_internal_alter_policy_stmt() const {
  return node_case() == kAlterPolicyStmt ? *_impl_.node_.alter_policy_stmt_ : reinterpret_cast<::pg_query::AlterPolicyStmt&>(::pg_query::_AlterPolicyStmt_default_instance_);
}
inline const ::pg_query::AlterPolicyStmt& Node::alter_policy_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterPolicyStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_policy_stmt_;
    _impl_.node_.alter_policy_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_policy_stmt(::pg_query::AlterPolicyStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_policy_stmt();
    _impl_.node_.alter_policy_stmt_ = value;
  }
  // @@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 (node_case() != kAlterPolicyStmt) {
    clear_node();
    set_has_alter_policy_stmt();
    _impl_.node_.alter_policy_stmt_ = CreateMaybeMessage<::pg_query::AlterPolicyStmt>(GetArena());
  }
  return _impl_.node_.alter_policy_stmt_;
}
inline ::pg_query::AlterPolicyStmt* Node::mutable_alter_policy_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterPolicyStmt* _msg = _internal_mutable_alter_policy_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_policy_stmt)
  return _msg;
}

// .pg_query.CreateAmStmt create_am_stmt = 158 [json_name = "CreateAmStmt"];
inline bool Node::has_create_am_stmt() const {
  return node_case() == kCreateAmStmt;
}
inline bool Node::_internal_has_create_am_stmt() const {
  return node_case() == kCreateAmStmt;
}
inline void Node::set_has_create_am_stmt() {
  _impl_._oneof_case_[0] = kCreateAmStmt;
}
inline void Node::clear_create_am_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateAmStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateAmStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_am_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_am_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateAmStmt& Node::_internal_create_am_stmt() const {
  return node_case() == kCreateAmStmt ? *_impl_.node_.create_am_stmt_ : reinterpret_cast<::pg_query::CreateAmStmt&>(::pg_query::_CreateAmStmt_default_instance_);
}
inline const ::pg_query::CreateAmStmt& Node::create_am_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateAmStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_am_stmt_;
    _impl_.node_.create_am_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_am_stmt(::pg_query::CreateAmStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_am_stmt();
    _impl_.node_.create_am_stmt_ = value;
  }
  // @@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 (node_case() != kCreateAmStmt) {
    clear_node();
    set_has_create_am_stmt();
    _impl_.node_.create_am_stmt_ = CreateMaybeMessage<::pg_query::CreateAmStmt>(GetArena());
  }
  return _impl_.node_.create_am_stmt_;
}
inline ::pg_query::CreateAmStmt* Node::mutable_create_am_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateAmStmt* _msg = _internal_mutable_create_am_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_am_stmt)
  return _msg;
}

// .pg_query.CreateTrigStmt create_trig_stmt = 159 [json_name = "CreateTrigStmt"];
inline bool Node::has_create_trig_stmt() const {
  return node_case() == kCreateTrigStmt;
}
inline bool Node::_internal_has_create_trig_stmt() const {
  return node_case() == kCreateTrigStmt;
}
inline void Node::set_has_create_trig_stmt() {
  _impl_._oneof_case_[0] = kCreateTrigStmt;
}
inline void Node::clear_create_trig_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateTrigStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateTrigStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_trig_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_trig_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateTrigStmt& Node::_internal_create_trig_stmt() const {
  return node_case() == kCreateTrigStmt ? *_impl_.node_.create_trig_stmt_ : reinterpret_cast<::pg_query::CreateTrigStmt&>(::pg_query::_CreateTrigStmt_default_instance_);
}
inline const ::pg_query::CreateTrigStmt& Node::create_trig_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateTrigStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_trig_stmt_;
    _impl_.node_.create_trig_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_trig_stmt(::pg_query::CreateTrigStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_trig_stmt();
    _impl_.node_.create_trig_stmt_ = value;
  }
  // @@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 (node_case() != kCreateTrigStmt) {
    clear_node();
    set_has_create_trig_stmt();
    _impl_.node_.create_trig_stmt_ = CreateMaybeMessage<::pg_query::CreateTrigStmt>(GetArena());
  }
  return _impl_.node_.create_trig_stmt_;
}
inline ::pg_query::CreateTrigStmt* Node::mutable_create_trig_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateTrigStmt* _msg = _internal_mutable_create_trig_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_trig_stmt)
  return _msg;
}

// .pg_query.CreateEventTrigStmt create_event_trig_stmt = 160 [json_name = "CreateEventTrigStmt"];
inline bool Node::has_create_event_trig_stmt() const {
  return node_case() == kCreateEventTrigStmt;
}
inline bool Node::_internal_has_create_event_trig_stmt() const {
  return node_case() == kCreateEventTrigStmt;
}
inline void Node::set_has_create_event_trig_stmt() {
  _impl_._oneof_case_[0] = kCreateEventTrigStmt;
}
inline void Node::clear_create_event_trig_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateEventTrigStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateEventTrigStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_event_trig_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_event_trig_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateEventTrigStmt& Node::_internal_create_event_trig_stmt() const {
  return node_case() == kCreateEventTrigStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateEventTrigStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_event_trig_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_event_trig_stmt();
    _impl_.node_.create_event_trig_stmt_ = value;
  }
  // @@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 (node_case() != kCreateEventTrigStmt) {
    clear_node();
    set_has_create_event_trig_stmt();
    _impl_.node_.create_event_trig_stmt_ = CreateMaybeMessage<::pg_query::CreateEventTrigStmt>(GetArena());
  }
  return _impl_.node_.create_event_trig_stmt_;
}
inline ::pg_query::CreateEventTrigStmt* Node::mutable_create_event_trig_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateEventTrigStmt* _msg = _internal_mutable_create_event_trig_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_event_trig_stmt)
  return _msg;
}

// .pg_query.AlterEventTrigStmt alter_event_trig_stmt = 161 [json_name = "AlterEventTrigStmt"];
inline bool Node::has_alter_event_trig_stmt() const {
  return node_case() == kAlterEventTrigStmt;
}
inline bool Node::_internal_has_alter_event_trig_stmt() const {
  return node_case() == kAlterEventTrigStmt;
}
inline void Node::set_has_alter_event_trig_stmt() {
  _impl_._oneof_case_[0] = kAlterEventTrigStmt;
}
inline void Node::clear_alter_event_trig_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterEventTrigStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterEventTrigStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_event_trig_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_event_trig_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterEventTrigStmt& Node::_internal_alter_event_trig_stmt() const {
  return node_case() == kAlterEventTrigStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterEventTrigStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_event_trig_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_event_trig_stmt();
    _impl_.node_.alter_event_trig_stmt_ = value;
  }
  // @@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 (node_case() != kAlterEventTrigStmt) {
    clear_node();
    set_has_alter_event_trig_stmt();
    _impl_.node_.alter_event_trig_stmt_ = CreateMaybeMessage<::pg_query::AlterEventTrigStmt>(GetArena());
  }
  return _impl_.node_.alter_event_trig_stmt_;
}
inline ::pg_query::AlterEventTrigStmt* Node::mutable_alter_event_trig_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterEventTrigStmt* _msg = _internal_mutable_alter_event_trig_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_event_trig_stmt)
  return _msg;
}

// .pg_query.CreatePLangStmt create_plang_stmt = 162 [json_name = "CreatePLangStmt"];
inline bool Node::has_create_plang_stmt() const {
  return node_case() == kCreatePlangStmt;
}
inline bool Node::_internal_has_create_plang_stmt() const {
  return node_case() == kCreatePlangStmt;
}
inline void Node::set_has_create_plang_stmt() {
  _impl_._oneof_case_[0] = kCreatePlangStmt;
}
inline void Node::clear_create_plang_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreatePlangStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreatePlangStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_plang_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_plang_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreatePLangStmt& Node::_internal_create_plang_stmt() const {
  return node_case() == kCreatePlangStmt ? *_impl_.node_.create_plang_stmt_ : reinterpret_cast<::pg_query::CreatePLangStmt&>(::pg_query::_CreatePLangStmt_default_instance_);
}
inline const ::pg_query::CreatePLangStmt& Node::create_plang_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreatePlangStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_plang_stmt_;
    _impl_.node_.create_plang_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_plang_stmt(::pg_query::CreatePLangStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_plang_stmt();
    _impl_.node_.create_plang_stmt_ = value;
  }
  // @@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 (node_case() != kCreatePlangStmt) {
    clear_node();
    set_has_create_plang_stmt();
    _impl_.node_.create_plang_stmt_ = CreateMaybeMessage<::pg_query::CreatePLangStmt>(GetArena());
  }
  return _impl_.node_.create_plang_stmt_;
}
inline ::pg_query::CreatePLangStmt* Node::mutable_create_plang_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreatePLangStmt* _msg = _internal_mutable_create_plang_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_plang_stmt)
  return _msg;
}

// .pg_query.CreateRoleStmt create_role_stmt = 163 [json_name = "CreateRoleStmt"];
inline bool Node::has_create_role_stmt() const {
  return node_case() == kCreateRoleStmt;
}
inline bool Node::_internal_has_create_role_stmt() const {
  return node_case() == kCreateRoleStmt;
}
inline void Node::set_has_create_role_stmt() {
  _impl_._oneof_case_[0] = kCreateRoleStmt;
}
inline void Node::clear_create_role_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateRoleStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateRoleStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_role_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateRoleStmt& Node::_internal_create_role_stmt() const {
  return node_case() == kCreateRoleStmt ? *_impl_.node_.create_role_stmt_ : reinterpret_cast<::pg_query::CreateRoleStmt&>(::pg_query::_CreateRoleStmt_default_instance_);
}
inline const ::pg_query::CreateRoleStmt& Node::create_role_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateRoleStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_role_stmt_;
    _impl_.node_.create_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_role_stmt(::pg_query::CreateRoleStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_role_stmt();
    _impl_.node_.create_role_stmt_ = value;
  }
  // @@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 (node_case() != kCreateRoleStmt) {
    clear_node();
    set_has_create_role_stmt();
    _impl_.node_.create_role_stmt_ = CreateMaybeMessage<::pg_query::CreateRoleStmt>(GetArena());
  }
  return _impl_.node_.create_role_stmt_;
}
inline ::pg_query::CreateRoleStmt* Node::mutable_create_role_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateRoleStmt* _msg = _internal_mutable_create_role_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_role_stmt)
  return _msg;
}

// .pg_query.AlterRoleStmt alter_role_stmt = 164 [json_name = "AlterRoleStmt"];
inline bool Node::has_alter_role_stmt() const {
  return node_case() == kAlterRoleStmt;
}
inline bool Node::_internal_has_alter_role_stmt() const {
  return node_case() == kAlterRoleStmt;
}
inline void Node::set_has_alter_role_stmt() {
  _impl_._oneof_case_[0] = kAlterRoleStmt;
}
inline void Node::clear_alter_role_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterRoleStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterRoleStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_role_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterRoleStmt& Node::_internal_alter_role_stmt() const {
  return node_case() == kAlterRoleStmt ? *_impl_.node_.alter_role_stmt_ : reinterpret_cast<::pg_query::AlterRoleStmt&>(::pg_query::_AlterRoleStmt_default_instance_);
}
inline const ::pg_query::AlterRoleStmt& Node::alter_role_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterRoleStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_role_stmt_;
    _impl_.node_.alter_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_role_stmt(::pg_query::AlterRoleStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_role_stmt();
    _impl_.node_.alter_role_stmt_ = value;
  }
  // @@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 (node_case() != kAlterRoleStmt) {
    clear_node();
    set_has_alter_role_stmt();
    _impl_.node_.alter_role_stmt_ = CreateMaybeMessage<::pg_query::AlterRoleStmt>(GetArena());
  }
  return _impl_.node_.alter_role_stmt_;
}
inline ::pg_query::AlterRoleStmt* Node::mutable_alter_role_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterRoleStmt* _msg = _internal_mutable_alter_role_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_role_stmt)
  return _msg;
}

// .pg_query.AlterRoleSetStmt alter_role_set_stmt = 165 [json_name = "AlterRoleSetStmt"];
inline bool Node::has_alter_role_set_stmt() const {
  return node_case() == kAlterRoleSetStmt;
}
inline bool Node::_internal_has_alter_role_set_stmt() const {
  return node_case() == kAlterRoleSetStmt;
}
inline void Node::set_has_alter_role_set_stmt() {
  _impl_._oneof_case_[0] = kAlterRoleSetStmt;
}
inline void Node::clear_alter_role_set_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterRoleSetStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterRoleSetStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_role_set_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_role_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterRoleSetStmt& Node::_internal_alter_role_set_stmt() const {
  return node_case() == kAlterRoleSetStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterRoleSetStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_role_set_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_role_set_stmt();
    _impl_.node_.alter_role_set_stmt_ = value;
  }
  // @@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 (node_case() != kAlterRoleSetStmt) {
    clear_node();
    set_has_alter_role_set_stmt();
    _impl_.node_.alter_role_set_stmt_ = CreateMaybeMessage<::pg_query::AlterRoleSetStmt>(GetArena());
  }
  return _impl_.node_.alter_role_set_stmt_;
}
inline ::pg_query::AlterRoleSetStmt* Node::mutable_alter_role_set_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterRoleSetStmt* _msg = _internal_mutable_alter_role_set_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_role_set_stmt)
  return _msg;
}

// .pg_query.DropRoleStmt drop_role_stmt = 166 [json_name = "DropRoleStmt"];
inline bool Node::has_drop_role_stmt() const {
  return node_case() == kDropRoleStmt;
}
inline bool Node::_internal_has_drop_role_stmt() const {
  return node_case() == kDropRoleStmt;
}
inline void Node::set_has_drop_role_stmt() {
  _impl_._oneof_case_[0] = kDropRoleStmt;
}
inline void Node::clear_drop_role_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDropRoleStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDropRoleStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.drop_role_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.drop_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropRoleStmt& Node::_internal_drop_role_stmt() const {
  return node_case() == kDropRoleStmt ? *_impl_.node_.drop_role_stmt_ : reinterpret_cast<::pg_query::DropRoleStmt&>(::pg_query::_DropRoleStmt_default_instance_);
}
inline const ::pg_query::DropRoleStmt& Node::drop_role_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDropRoleStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.drop_role_stmt_;
    _impl_.node_.drop_role_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_drop_role_stmt(::pg_query::DropRoleStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_drop_role_stmt();
    _impl_.node_.drop_role_stmt_ = value;
  }
  // @@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 (node_case() != kDropRoleStmt) {
    clear_node();
    set_has_drop_role_stmt();
    _impl_.node_.drop_role_stmt_ = CreateMaybeMessage<::pg_query::DropRoleStmt>(GetArena());
  }
  return _impl_.node_.drop_role_stmt_;
}
inline ::pg_query::DropRoleStmt* Node::mutable_drop_role_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DropRoleStmt* _msg = _internal_mutable_drop_role_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_role_stmt)
  return _msg;
}

// .pg_query.CreateSeqStmt create_seq_stmt = 167 [json_name = "CreateSeqStmt"];
inline bool Node::has_create_seq_stmt() const {
  return node_case() == kCreateSeqStmt;
}
inline bool Node::_internal_has_create_seq_stmt() const {
  return node_case() == kCreateSeqStmt;
}
inline void Node::set_has_create_seq_stmt() {
  _impl_._oneof_case_[0] = kCreateSeqStmt;
}
inline void Node::clear_create_seq_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateSeqStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateSeqStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_seq_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_seq_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateSeqStmt& Node::_internal_create_seq_stmt() const {
  return node_case() == kCreateSeqStmt ? *_impl_.node_.create_seq_stmt_ : reinterpret_cast<::pg_query::CreateSeqStmt&>(::pg_query::_CreateSeqStmt_default_instance_);
}
inline const ::pg_query::CreateSeqStmt& Node::create_seq_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateSeqStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_seq_stmt_;
    _impl_.node_.create_seq_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_seq_stmt(::pg_query::CreateSeqStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_seq_stmt();
    _impl_.node_.create_seq_stmt_ = value;
  }
  // @@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 (node_case() != kCreateSeqStmt) {
    clear_node();
    set_has_create_seq_stmt();
    _impl_.node_.create_seq_stmt_ = CreateMaybeMessage<::pg_query::CreateSeqStmt>(GetArena());
  }
  return _impl_.node_.create_seq_stmt_;
}
inline ::pg_query::CreateSeqStmt* Node::mutable_create_seq_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateSeqStmt* _msg = _internal_mutable_create_seq_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_seq_stmt)
  return _msg;
}

// .pg_query.AlterSeqStmt alter_seq_stmt = 168 [json_name = "AlterSeqStmt"];
inline bool Node::has_alter_seq_stmt() const {
  return node_case() == kAlterSeqStmt;
}
inline bool Node::_internal_has_alter_seq_stmt() const {
  return node_case() == kAlterSeqStmt;
}
inline void Node::set_has_alter_seq_stmt() {
  _impl_._oneof_case_[0] = kAlterSeqStmt;
}
inline void Node::clear_alter_seq_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterSeqStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterSeqStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_seq_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_seq_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterSeqStmt& Node::_internal_alter_seq_stmt() const {
  return node_case() == kAlterSeqStmt ? *_impl_.node_.alter_seq_stmt_ : reinterpret_cast<::pg_query::AlterSeqStmt&>(::pg_query::_AlterSeqStmt_default_instance_);
}
inline const ::pg_query::AlterSeqStmt& Node::alter_seq_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterSeqStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_seq_stmt_;
    _impl_.node_.alter_seq_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_seq_stmt(::pg_query::AlterSeqStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_seq_stmt();
    _impl_.node_.alter_seq_stmt_ = value;
  }
  // @@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 (node_case() != kAlterSeqStmt) {
    clear_node();
    set_has_alter_seq_stmt();
    _impl_.node_.alter_seq_stmt_ = CreateMaybeMessage<::pg_query::AlterSeqStmt>(GetArena());
  }
  return _impl_.node_.alter_seq_stmt_;
}
inline ::pg_query::AlterSeqStmt* Node::mutable_alter_seq_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterSeqStmt* _msg = _internal_mutable_alter_seq_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_seq_stmt)
  return _msg;
}

// .pg_query.DefineStmt define_stmt = 169 [json_name = "DefineStmt"];
inline bool Node::has_define_stmt() const {
  return node_case() == kDefineStmt;
}
inline bool Node::_internal_has_define_stmt() const {
  return node_case() == kDefineStmt;
}
inline void Node::set_has_define_stmt() {
  _impl_._oneof_case_[0] = kDefineStmt;
}
inline void Node::clear_define_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDefineStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDefineStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.define_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.define_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DefineStmt& Node::_internal_define_stmt() const {
  return node_case() == kDefineStmt ? *_impl_.node_.define_stmt_ : reinterpret_cast<::pg_query::DefineStmt&>(::pg_query::_DefineStmt_default_instance_);
}
inline const ::pg_query::DefineStmt& Node::define_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDefineStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.define_stmt_;
    _impl_.node_.define_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_define_stmt(::pg_query::DefineStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_define_stmt();
    _impl_.node_.define_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.define_stmt)
}
inline ::pg_query::DefineStmt* Node::_internal_mutable_define_stmt() {
  if (node_case() != kDefineStmt) {
    clear_node();
    set_has_define_stmt();
    _impl_.node_.define_stmt_ = CreateMaybeMessage<::pg_query::DefineStmt>(GetArena());
  }
  return _impl_.node_.define_stmt_;
}
inline ::pg_query::DefineStmt* Node::mutable_define_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DefineStmt* _msg = _internal_mutable_define_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.define_stmt)
  return _msg;
}

// .pg_query.CreateDomainStmt create_domain_stmt = 170 [json_name = "CreateDomainStmt"];
inline bool Node::has_create_domain_stmt() const {
  return node_case() == kCreateDomainStmt;
}
inline bool Node::_internal_has_create_domain_stmt() const {
  return node_case() == kCreateDomainStmt;
}
inline void Node::set_has_create_domain_stmt() {
  _impl_._oneof_case_[0] = kCreateDomainStmt;
}
inline void Node::clear_create_domain_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateDomainStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateDomainStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_domain_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_domain_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateDomainStmt& Node::_internal_create_domain_stmt() const {
  return node_case() == kCreateDomainStmt ? *_impl_.node_.create_domain_stmt_ : reinterpret_cast<::pg_query::CreateDomainStmt&>(::pg_query::_CreateDomainStmt_default_instance_);
}
inline const ::pg_query::CreateDomainStmt& Node::create_domain_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateDomainStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_domain_stmt_;
    _impl_.node_.create_domain_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_domain_stmt(::pg_query::CreateDomainStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_domain_stmt();
    _impl_.node_.create_domain_stmt_ = value;
  }
  // @@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 (node_case() != kCreateDomainStmt) {
    clear_node();
    set_has_create_domain_stmt();
    _impl_.node_.create_domain_stmt_ = CreateMaybeMessage<::pg_query::CreateDomainStmt>(GetArena());
  }
  return _impl_.node_.create_domain_stmt_;
}
inline ::pg_query::CreateDomainStmt* Node::mutable_create_domain_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateDomainStmt* _msg = _internal_mutable_create_domain_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_domain_stmt)
  return _msg;
}

// .pg_query.CreateOpClassStmt create_op_class_stmt = 171 [json_name = "CreateOpClassStmt"];
inline bool Node::has_create_op_class_stmt() const {
  return node_case() == kCreateOpClassStmt;
}
inline bool Node::_internal_has_create_op_class_stmt() const {
  return node_case() == kCreateOpClassStmt;
}
inline void Node::set_has_create_op_class_stmt() {
  _impl_._oneof_case_[0] = kCreateOpClassStmt;
}
inline void Node::clear_create_op_class_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateOpClassStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateOpClassStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_op_class_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_op_class_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateOpClassStmt& Node::_internal_create_op_class_stmt() const {
  return node_case() == kCreateOpClassStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateOpClassStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_op_class_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_op_class_stmt();
    _impl_.node_.create_op_class_stmt_ = value;
  }
  // @@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 (node_case() != kCreateOpClassStmt) {
    clear_node();
    set_has_create_op_class_stmt();
    _impl_.node_.create_op_class_stmt_ = CreateMaybeMessage<::pg_query::CreateOpClassStmt>(GetArena());
  }
  return _impl_.node_.create_op_class_stmt_;
}
inline ::pg_query::CreateOpClassStmt* Node::mutable_create_op_class_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateOpClassStmt* _msg = _internal_mutable_create_op_class_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_op_class_stmt)
  return _msg;
}

// .pg_query.CreateOpClassItem create_op_class_item = 172 [json_name = "CreateOpClassItem"];
inline bool Node::has_create_op_class_item() const {
  return node_case() == kCreateOpClassItem;
}
inline bool Node::_internal_has_create_op_class_item() const {
  return node_case() == kCreateOpClassItem;
}
inline void Node::set_has_create_op_class_item() {
  _impl_._oneof_case_[0] = kCreateOpClassItem;
}
inline void Node::clear_create_op_class_item() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateOpClassItem) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateOpClassItem) {
    clear_has_node();
    auto* temp = _impl_.node_.create_op_class_item_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_op_class_item_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateOpClassItem& Node::_internal_create_op_class_item() const {
  return node_case() == kCreateOpClassItem ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateOpClassItem) {
    clear_has_node();
    auto* temp = _impl_.node_.create_op_class_item_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_op_class_item();
    _impl_.node_.create_op_class_item_ = value;
  }
  // @@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 (node_case() != kCreateOpClassItem) {
    clear_node();
    set_has_create_op_class_item();
    _impl_.node_.create_op_class_item_ = CreateMaybeMessage<::pg_query::CreateOpClassItem>(GetArena());
  }
  return _impl_.node_.create_op_class_item_;
}
inline ::pg_query::CreateOpClassItem* Node::mutable_create_op_class_item() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateOpClassItem* _msg = _internal_mutable_create_op_class_item();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_op_class_item)
  return _msg;
}

// .pg_query.CreateOpFamilyStmt create_op_family_stmt = 173 [json_name = "CreateOpFamilyStmt"];
inline bool Node::has_create_op_family_stmt() const {
  return node_case() == kCreateOpFamilyStmt;
}
inline bool Node::_internal_has_create_op_family_stmt() const {
  return node_case() == kCreateOpFamilyStmt;
}
inline void Node::set_has_create_op_family_stmt() {
  _impl_._oneof_case_[0] = kCreateOpFamilyStmt;
}
inline void Node::clear_create_op_family_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateOpFamilyStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateOpFamilyStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_op_family_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_op_family_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateOpFamilyStmt& Node::_internal_create_op_family_stmt() const {
  return node_case() == kCreateOpFamilyStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateOpFamilyStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_op_family_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_op_family_stmt();
    _impl_.node_.create_op_family_stmt_ = value;
  }
  // @@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 (node_case() != kCreateOpFamilyStmt) {
    clear_node();
    set_has_create_op_family_stmt();
    _impl_.node_.create_op_family_stmt_ = CreateMaybeMessage<::pg_query::CreateOpFamilyStmt>(GetArena());
  }
  return _impl_.node_.create_op_family_stmt_;
}
inline ::pg_query::CreateOpFamilyStmt* Node::mutable_create_op_family_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateOpFamilyStmt* _msg = _internal_mutable_create_op_family_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_op_family_stmt)
  return _msg;
}

// .pg_query.AlterOpFamilyStmt alter_op_family_stmt = 174 [json_name = "AlterOpFamilyStmt"];
inline bool Node::has_alter_op_family_stmt() const {
  return node_case() == kAlterOpFamilyStmt;
}
inline bool Node::_internal_has_alter_op_family_stmt() const {
  return node_case() == kAlterOpFamilyStmt;
}
inline void Node::set_has_alter_op_family_stmt() {
  _impl_._oneof_case_[0] = kAlterOpFamilyStmt;
}
inline void Node::clear_alter_op_family_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterOpFamilyStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterOpFamilyStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_op_family_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_op_family_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterOpFamilyStmt& Node::_internal_alter_op_family_stmt() const {
  return node_case() == kAlterOpFamilyStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterOpFamilyStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_op_family_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_op_family_stmt();
    _impl_.node_.alter_op_family_stmt_ = value;
  }
  // @@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 (node_case() != kAlterOpFamilyStmt) {
    clear_node();
    set_has_alter_op_family_stmt();
    _impl_.node_.alter_op_family_stmt_ = CreateMaybeMessage<::pg_query::AlterOpFamilyStmt>(GetArena());
  }
  return _impl_.node_.alter_op_family_stmt_;
}
inline ::pg_query::AlterOpFamilyStmt* Node::mutable_alter_op_family_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterOpFamilyStmt* _msg = _internal_mutable_alter_op_family_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_op_family_stmt)
  return _msg;
}

// .pg_query.DropStmt drop_stmt = 175 [json_name = "DropStmt"];
inline bool Node::has_drop_stmt() const {
  return node_case() == kDropStmt;
}
inline bool Node::_internal_has_drop_stmt() const {
  return node_case() == kDropStmt;
}
inline void Node::set_has_drop_stmt() {
  _impl_._oneof_case_[0] = kDropStmt;
}
inline void Node::clear_drop_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDropStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDropStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.drop_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.drop_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropStmt& Node::_internal_drop_stmt() const {
  return node_case() == kDropStmt ? *_impl_.node_.drop_stmt_ : reinterpret_cast<::pg_query::DropStmt&>(::pg_query::_DropStmt_default_instance_);
}
inline const ::pg_query::DropStmt& Node::drop_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDropStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.drop_stmt_;
    _impl_.node_.drop_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_drop_stmt(::pg_query::DropStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_drop_stmt();
    _impl_.node_.drop_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_stmt)
}
inline ::pg_query::DropStmt* Node::_internal_mutable_drop_stmt() {
  if (node_case() != kDropStmt) {
    clear_node();
    set_has_drop_stmt();
    _impl_.node_.drop_stmt_ = CreateMaybeMessage<::pg_query::DropStmt>(GetArena());
  }
  return _impl_.node_.drop_stmt_;
}
inline ::pg_query::DropStmt* Node::mutable_drop_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DropStmt* _msg = _internal_mutable_drop_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_stmt)
  return _msg;
}

// .pg_query.TruncateStmt truncate_stmt = 176 [json_name = "TruncateStmt"];
inline bool Node::has_truncate_stmt() const {
  return node_case() == kTruncateStmt;
}
inline bool Node::_internal_has_truncate_stmt() const {
  return node_case() == kTruncateStmt;
}
inline void Node::set_has_truncate_stmt() {
  _impl_._oneof_case_[0] = kTruncateStmt;
}
inline void Node::clear_truncate_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kTruncateStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kTruncateStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.truncate_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.truncate_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TruncateStmt& Node::_internal_truncate_stmt() const {
  return node_case() == kTruncateStmt ? *_impl_.node_.truncate_stmt_ : reinterpret_cast<::pg_query::TruncateStmt&>(::pg_query::_TruncateStmt_default_instance_);
}
inline const ::pg_query::TruncateStmt& Node::truncate_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kTruncateStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.truncate_stmt_;
    _impl_.node_.truncate_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_truncate_stmt(::pg_query::TruncateStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_truncate_stmt();
    _impl_.node_.truncate_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.truncate_stmt)
}
inline ::pg_query::TruncateStmt* Node::_internal_mutable_truncate_stmt() {
  if (node_case() != kTruncateStmt) {
    clear_node();
    set_has_truncate_stmt();
    _impl_.node_.truncate_stmt_ = CreateMaybeMessage<::pg_query::TruncateStmt>(GetArena());
  }
  return _impl_.node_.truncate_stmt_;
}
inline ::pg_query::TruncateStmt* Node::mutable_truncate_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TruncateStmt* _msg = _internal_mutable_truncate_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.truncate_stmt)
  return _msg;
}

// .pg_query.CommentStmt comment_stmt = 177 [json_name = "CommentStmt"];
inline bool Node::has_comment_stmt() const {
  return node_case() == kCommentStmt;
}
inline bool Node::_internal_has_comment_stmt() const {
  return node_case() == kCommentStmt;
}
inline void Node::set_has_comment_stmt() {
  _impl_._oneof_case_[0] = kCommentStmt;
}
inline void Node::clear_comment_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCommentStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCommentStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.comment_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.comment_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CommentStmt& Node::_internal_comment_stmt() const {
  return node_case() == kCommentStmt ? *_impl_.node_.comment_stmt_ : reinterpret_cast<::pg_query::CommentStmt&>(::pg_query::_CommentStmt_default_instance_);
}
inline const ::pg_query::CommentStmt& Node::comment_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCommentStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.comment_stmt_;
    _impl_.node_.comment_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_comment_stmt(::pg_query::CommentStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_comment_stmt();
    _impl_.node_.comment_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.comment_stmt)
}
inline ::pg_query::CommentStmt* Node::_internal_mutable_comment_stmt() {
  if (node_case() != kCommentStmt) {
    clear_node();
    set_has_comment_stmt();
    _impl_.node_.comment_stmt_ = CreateMaybeMessage<::pg_query::CommentStmt>(GetArena());
  }
  return _impl_.node_.comment_stmt_;
}
inline ::pg_query::CommentStmt* Node::mutable_comment_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CommentStmt* _msg = _internal_mutable_comment_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.comment_stmt)
  return _msg;
}

// .pg_query.SecLabelStmt sec_label_stmt = 178 [json_name = "SecLabelStmt"];
inline bool Node::has_sec_label_stmt() const {
  return node_case() == kSecLabelStmt;
}
inline bool Node::_internal_has_sec_label_stmt() const {
  return node_case() == kSecLabelStmt;
}
inline void Node::set_has_sec_label_stmt() {
  _impl_._oneof_case_[0] = kSecLabelStmt;
}
inline void Node::clear_sec_label_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kSecLabelStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kSecLabelStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.sec_label_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.sec_label_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::SecLabelStmt& Node::_internal_sec_label_stmt() const {
  return node_case() == kSecLabelStmt ? *_impl_.node_.sec_label_stmt_ : reinterpret_cast<::pg_query::SecLabelStmt&>(::pg_query::_SecLabelStmt_default_instance_);
}
inline const ::pg_query::SecLabelStmt& Node::sec_label_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kSecLabelStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.sec_label_stmt_;
    _impl_.node_.sec_label_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_sec_label_stmt(::pg_query::SecLabelStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_sec_label_stmt();
    _impl_.node_.sec_label_stmt_ = value;
  }
  // @@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 (node_case() != kSecLabelStmt) {
    clear_node();
    set_has_sec_label_stmt();
    _impl_.node_.sec_label_stmt_ = CreateMaybeMessage<::pg_query::SecLabelStmt>(GetArena());
  }
  return _impl_.node_.sec_label_stmt_;
}
inline ::pg_query::SecLabelStmt* Node::mutable_sec_label_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SecLabelStmt* _msg = _internal_mutable_sec_label_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.sec_label_stmt)
  return _msg;
}

// .pg_query.DeclareCursorStmt declare_cursor_stmt = 179 [json_name = "DeclareCursorStmt"];
inline bool Node::has_declare_cursor_stmt() const {
  return node_case() == kDeclareCursorStmt;
}
inline bool Node::_internal_has_declare_cursor_stmt() const {
  return node_case() == kDeclareCursorStmt;
}
inline void Node::set_has_declare_cursor_stmt() {
  _impl_._oneof_case_[0] = kDeclareCursorStmt;
}
inline void Node::clear_declare_cursor_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDeclareCursorStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDeclareCursorStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.declare_cursor_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.declare_cursor_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DeclareCursorStmt& Node::_internal_declare_cursor_stmt() const {
  return node_case() == kDeclareCursorStmt ? *_impl_.node_.declare_cursor_stmt_ : reinterpret_cast<::pg_query::DeclareCursorStmt&>(::pg_query::_DeclareCursorStmt_default_instance_);
}
inline const ::pg_query::DeclareCursorStmt& Node::declare_cursor_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDeclareCursorStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.declare_cursor_stmt_;
    _impl_.node_.declare_cursor_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_declare_cursor_stmt(::pg_query::DeclareCursorStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_declare_cursor_stmt();
    _impl_.node_.declare_cursor_stmt_ = value;
  }
  // @@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 (node_case() != kDeclareCursorStmt) {
    clear_node();
    set_has_declare_cursor_stmt();
    _impl_.node_.declare_cursor_stmt_ = CreateMaybeMessage<::pg_query::DeclareCursorStmt>(GetArena());
  }
  return _impl_.node_.declare_cursor_stmt_;
}
inline ::pg_query::DeclareCursorStmt* Node::mutable_declare_cursor_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DeclareCursorStmt* _msg = _internal_mutable_declare_cursor_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.declare_cursor_stmt)
  return _msg;
}

// .pg_query.ClosePortalStmt close_portal_stmt = 180 [json_name = "ClosePortalStmt"];
inline bool Node::has_close_portal_stmt() const {
  return node_case() == kClosePortalStmt;
}
inline bool Node::_internal_has_close_portal_stmt() const {
  return node_case() == kClosePortalStmt;
}
inline void Node::set_has_close_portal_stmt() {
  _impl_._oneof_case_[0] = kClosePortalStmt;
}
inline void Node::clear_close_portal_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kClosePortalStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kClosePortalStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.close_portal_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.close_portal_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ClosePortalStmt& Node::_internal_close_portal_stmt() const {
  return node_case() == kClosePortalStmt ? *_impl_.node_.close_portal_stmt_ : reinterpret_cast<::pg_query::ClosePortalStmt&>(::pg_query::_ClosePortalStmt_default_instance_);
}
inline const ::pg_query::ClosePortalStmt& Node::close_portal_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kClosePortalStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.close_portal_stmt_;
    _impl_.node_.close_portal_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_close_portal_stmt(::pg_query::ClosePortalStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_close_portal_stmt();
    _impl_.node_.close_portal_stmt_ = value;
  }
  // @@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 (node_case() != kClosePortalStmt) {
    clear_node();
    set_has_close_portal_stmt();
    _impl_.node_.close_portal_stmt_ = CreateMaybeMessage<::pg_query::ClosePortalStmt>(GetArena());
  }
  return _impl_.node_.close_portal_stmt_;
}
inline ::pg_query::ClosePortalStmt* Node::mutable_close_portal_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ClosePortalStmt* _msg = _internal_mutable_close_portal_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.close_portal_stmt)
  return _msg;
}

// .pg_query.FetchStmt fetch_stmt = 181 [json_name = "FetchStmt"];
inline bool Node::has_fetch_stmt() const {
  return node_case() == kFetchStmt;
}
inline bool Node::_internal_has_fetch_stmt() const {
  return node_case() == kFetchStmt;
}
inline void Node::set_has_fetch_stmt() {
  _impl_._oneof_case_[0] = kFetchStmt;
}
inline void Node::clear_fetch_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kFetchStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kFetchStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.fetch_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.fetch_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FetchStmt& Node::_internal_fetch_stmt() const {
  return node_case() == kFetchStmt ? *_impl_.node_.fetch_stmt_ : reinterpret_cast<::pg_query::FetchStmt&>(::pg_query::_FetchStmt_default_instance_);
}
inline const ::pg_query::FetchStmt& Node::fetch_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kFetchStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.fetch_stmt_;
    _impl_.node_.fetch_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_fetch_stmt(::pg_query::FetchStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_fetch_stmt();
    _impl_.node_.fetch_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.fetch_stmt)
}
inline ::pg_query::FetchStmt* Node::_internal_mutable_fetch_stmt() {
  if (node_case() != kFetchStmt) {
    clear_node();
    set_has_fetch_stmt();
    _impl_.node_.fetch_stmt_ = CreateMaybeMessage<::pg_query::FetchStmt>(GetArena());
  }
  return _impl_.node_.fetch_stmt_;
}
inline ::pg_query::FetchStmt* Node::mutable_fetch_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::FetchStmt* _msg = _internal_mutable_fetch_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.fetch_stmt)
  return _msg;
}

// .pg_query.IndexStmt index_stmt = 182 [json_name = "IndexStmt"];
inline bool Node::has_index_stmt() const {
  return node_case() == kIndexStmt;
}
inline bool Node::_internal_has_index_stmt() const {
  return node_case() == kIndexStmt;
}
inline void Node::set_has_index_stmt() {
  _impl_._oneof_case_[0] = kIndexStmt;
}
inline void Node::clear_index_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kIndexStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kIndexStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.index_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.index_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::IndexStmt& Node::_internal_index_stmt() const {
  return node_case() == kIndexStmt ? *_impl_.node_.index_stmt_ : reinterpret_cast<::pg_query::IndexStmt&>(::pg_query::_IndexStmt_default_instance_);
}
inline const ::pg_query::IndexStmt& Node::index_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kIndexStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.index_stmt_;
    _impl_.node_.index_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_index_stmt(::pg_query::IndexStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_index_stmt();
    _impl_.node_.index_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.index_stmt)
}
inline ::pg_query::IndexStmt* Node::_internal_mutable_index_stmt() {
  if (node_case() != kIndexStmt) {
    clear_node();
    set_has_index_stmt();
    _impl_.node_.index_stmt_ = CreateMaybeMessage<::pg_query::IndexStmt>(GetArena());
  }
  return _impl_.node_.index_stmt_;
}
inline ::pg_query::IndexStmt* Node::mutable_index_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::IndexStmt* _msg = _internal_mutable_index_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.index_stmt)
  return _msg;
}

// .pg_query.CreateStatsStmt create_stats_stmt = 183 [json_name = "CreateStatsStmt"];
inline bool Node::has_create_stats_stmt() const {
  return node_case() == kCreateStatsStmt;
}
inline bool Node::_internal_has_create_stats_stmt() const {
  return node_case() == kCreateStatsStmt;
}
inline void Node::set_has_create_stats_stmt() {
  _impl_._oneof_case_[0] = kCreateStatsStmt;
}
inline void Node::clear_create_stats_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateStatsStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateStatsStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_stats_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_stats_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateStatsStmt& Node::_internal_create_stats_stmt() const {
  return node_case() == kCreateStatsStmt ? *_impl_.node_.create_stats_stmt_ : reinterpret_cast<::pg_query::CreateStatsStmt&>(::pg_query::_CreateStatsStmt_default_instance_);
}
inline const ::pg_query::CreateStatsStmt& Node::create_stats_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateStatsStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_stats_stmt_;
    _impl_.node_.create_stats_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_stats_stmt(::pg_query::CreateStatsStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_stats_stmt();
    _impl_.node_.create_stats_stmt_ = value;
  }
  // @@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 (node_case() != kCreateStatsStmt) {
    clear_node();
    set_has_create_stats_stmt();
    _impl_.node_.create_stats_stmt_ = CreateMaybeMessage<::pg_query::CreateStatsStmt>(GetArena());
  }
  return _impl_.node_.create_stats_stmt_;
}
inline ::pg_query::CreateStatsStmt* Node::mutable_create_stats_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateStatsStmt* _msg = _internal_mutable_create_stats_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_stats_stmt)
  return _msg;
}

// .pg_query.StatsElem stats_elem = 184 [json_name = "StatsElem"];
inline bool Node::has_stats_elem() const {
  return node_case() == kStatsElem;
}
inline bool Node::_internal_has_stats_elem() const {
  return node_case() == kStatsElem;
}
inline void Node::set_has_stats_elem() {
  _impl_._oneof_case_[0] = kStatsElem;
}
inline void Node::clear_stats_elem() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kStatsElem) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.stats_elem_;
    }
    clear_has_node();
  }
}
inline ::pg_query::StatsElem* Node::release_stats_elem() {
  // @@protoc_insertion_point(field_release:pg_query.Node.stats_elem)
  if (node_case() == kStatsElem) {
    clear_has_node();
    auto* temp = _impl_.node_.stats_elem_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.stats_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::StatsElem& Node::_internal_stats_elem() const {
  return node_case() == kStatsElem ? *_impl_.node_.stats_elem_ : reinterpret_cast<::pg_query::StatsElem&>(::pg_query::_StatsElem_default_instance_);
}
inline const ::pg_query::StatsElem& Node::stats_elem() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.stats_elem)
  return _internal_stats_elem();
}
inline ::pg_query::StatsElem* Node::unsafe_arena_release_stats_elem() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.stats_elem)
  if (node_case() == kStatsElem) {
    clear_has_node();
    auto* temp = _impl_.node_.stats_elem_;
    _impl_.node_.stats_elem_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_stats_elem(::pg_query::StatsElem* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_stats_elem();
    _impl_.node_.stats_elem_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.stats_elem)
}
inline ::pg_query::StatsElem* Node::_internal_mutable_stats_elem() {
  if (node_case() != kStatsElem) {
    clear_node();
    set_has_stats_elem();
    _impl_.node_.stats_elem_ = CreateMaybeMessage<::pg_query::StatsElem>(GetArena());
  }
  return _impl_.node_.stats_elem_;
}
inline ::pg_query::StatsElem* Node::mutable_stats_elem() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::StatsElem* _msg = _internal_mutable_stats_elem();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.stats_elem)
  return _msg;
}

// .pg_query.AlterStatsStmt alter_stats_stmt = 185 [json_name = "AlterStatsStmt"];
inline bool Node::has_alter_stats_stmt() const {
  return node_case() == kAlterStatsStmt;
}
inline bool Node::_internal_has_alter_stats_stmt() const {
  return node_case() == kAlterStatsStmt;
}
inline void Node::set_has_alter_stats_stmt() {
  _impl_._oneof_case_[0] = kAlterStatsStmt;
}
inline void Node::clear_alter_stats_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterStatsStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterStatsStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_stats_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_stats_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterStatsStmt& Node::_internal_alter_stats_stmt() const {
  return node_case() == kAlterStatsStmt ? *_impl_.node_.alter_stats_stmt_ : reinterpret_cast<::pg_query::AlterStatsStmt&>(::pg_query::_AlterStatsStmt_default_instance_);
}
inline const ::pg_query::AlterStatsStmt& Node::alter_stats_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterStatsStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_stats_stmt_;
    _impl_.node_.alter_stats_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_stats_stmt(::pg_query::AlterStatsStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_stats_stmt();
    _impl_.node_.alter_stats_stmt_ = value;
  }
  // @@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 (node_case() != kAlterStatsStmt) {
    clear_node();
    set_has_alter_stats_stmt();
    _impl_.node_.alter_stats_stmt_ = CreateMaybeMessage<::pg_query::AlterStatsStmt>(GetArena());
  }
  return _impl_.node_.alter_stats_stmt_;
}
inline ::pg_query::AlterStatsStmt* Node::mutable_alter_stats_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterStatsStmt* _msg = _internal_mutable_alter_stats_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_stats_stmt)
  return _msg;
}

// .pg_query.CreateFunctionStmt create_function_stmt = 186 [json_name = "CreateFunctionStmt"];
inline bool Node::has_create_function_stmt() const {
  return node_case() == kCreateFunctionStmt;
}
inline bool Node::_internal_has_create_function_stmt() const {
  return node_case() == kCreateFunctionStmt;
}
inline void Node::set_has_create_function_stmt() {
  _impl_._oneof_case_[0] = kCreateFunctionStmt;
}
inline void Node::clear_create_function_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateFunctionStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateFunctionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_function_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_function_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateFunctionStmt& Node::_internal_create_function_stmt() const {
  return node_case() == kCreateFunctionStmt ? *_impl_.node_.create_function_stmt_ : reinterpret_cast<::pg_query::CreateFunctionStmt&>(::pg_query::_CreateFunctionStmt_default_instance_);
}
inline const ::pg_query::CreateFunctionStmt& Node::create_function_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateFunctionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_function_stmt_;
    _impl_.node_.create_function_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_function_stmt(::pg_query::CreateFunctionStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_function_stmt();
    _impl_.node_.create_function_stmt_ = value;
  }
  // @@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 (node_case() != kCreateFunctionStmt) {
    clear_node();
    set_has_create_function_stmt();
    _impl_.node_.create_function_stmt_ = CreateMaybeMessage<::pg_query::CreateFunctionStmt>(GetArena());
  }
  return _impl_.node_.create_function_stmt_;
}
inline ::pg_query::CreateFunctionStmt* Node::mutable_create_function_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateFunctionStmt* _msg = _internal_mutable_create_function_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_function_stmt)
  return _msg;
}

// .pg_query.FunctionParameter function_parameter = 187 [json_name = "FunctionParameter"];
inline bool Node::has_function_parameter() const {
  return node_case() == kFunctionParameter;
}
inline bool Node::_internal_has_function_parameter() const {
  return node_case() == kFunctionParameter;
}
inline void Node::set_has_function_parameter() {
  _impl_._oneof_case_[0] = kFunctionParameter;
}
inline void Node::clear_function_parameter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kFunctionParameter) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kFunctionParameter) {
    clear_has_node();
    auto* temp = _impl_.node_.function_parameter_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.function_parameter_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::FunctionParameter& Node::_internal_function_parameter() const {
  return node_case() == kFunctionParameter ? *_impl_.node_.function_parameter_ : reinterpret_cast<::pg_query::FunctionParameter&>(::pg_query::_FunctionParameter_default_instance_);
}
inline const ::pg_query::FunctionParameter& Node::function_parameter() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kFunctionParameter) {
    clear_has_node();
    auto* temp = _impl_.node_.function_parameter_;
    _impl_.node_.function_parameter_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_function_parameter(::pg_query::FunctionParameter* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_function_parameter();
    _impl_.node_.function_parameter_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.function_parameter)
}
inline ::pg_query::FunctionParameter* Node::_internal_mutable_function_parameter() {
  if (node_case() != kFunctionParameter) {
    clear_node();
    set_has_function_parameter();
    _impl_.node_.function_parameter_ = CreateMaybeMessage<::pg_query::FunctionParameter>(GetArena());
  }
  return _impl_.node_.function_parameter_;
}
inline ::pg_query::FunctionParameter* Node::mutable_function_parameter() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::FunctionParameter* _msg = _internal_mutable_function_parameter();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.function_parameter)
  return _msg;
}

// .pg_query.AlterFunctionStmt alter_function_stmt = 188 [json_name = "AlterFunctionStmt"];
inline bool Node::has_alter_function_stmt() const {
  return node_case() == kAlterFunctionStmt;
}
inline bool Node::_internal_has_alter_function_stmt() const {
  return node_case() == kAlterFunctionStmt;
}
inline void Node::set_has_alter_function_stmt() {
  _impl_._oneof_case_[0] = kAlterFunctionStmt;
}
inline void Node::clear_alter_function_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterFunctionStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterFunctionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_function_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_function_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterFunctionStmt& Node::_internal_alter_function_stmt() const {
  return node_case() == kAlterFunctionStmt ? *_impl_.node_.alter_function_stmt_ : reinterpret_cast<::pg_query::AlterFunctionStmt&>(::pg_query::_AlterFunctionStmt_default_instance_);
}
inline const ::pg_query::AlterFunctionStmt& Node::alter_function_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterFunctionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_function_stmt_;
    _impl_.node_.alter_function_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_function_stmt(::pg_query::AlterFunctionStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_function_stmt();
    _impl_.node_.alter_function_stmt_ = value;
  }
  // @@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 (node_case() != kAlterFunctionStmt) {
    clear_node();
    set_has_alter_function_stmt();
    _impl_.node_.alter_function_stmt_ = CreateMaybeMessage<::pg_query::AlterFunctionStmt>(GetArena());
  }
  return _impl_.node_.alter_function_stmt_;
}
inline ::pg_query::AlterFunctionStmt* Node::mutable_alter_function_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterFunctionStmt* _msg = _internal_mutable_alter_function_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_function_stmt)
  return _msg;
}

// .pg_query.DoStmt do_stmt = 189 [json_name = "DoStmt"];
inline bool Node::has_do_stmt() const {
  return node_case() == kDoStmt;
}
inline bool Node::_internal_has_do_stmt() const {
  return node_case() == kDoStmt;
}
inline void Node::set_has_do_stmt() {
  _impl_._oneof_case_[0] = kDoStmt;
}
inline void Node::clear_do_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDoStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDoStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.do_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.do_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DoStmt& Node::_internal_do_stmt() const {
  return node_case() == kDoStmt ? *_impl_.node_.do_stmt_ : reinterpret_cast<::pg_query::DoStmt&>(::pg_query::_DoStmt_default_instance_);
}
inline const ::pg_query::DoStmt& Node::do_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDoStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.do_stmt_;
    _impl_.node_.do_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_do_stmt(::pg_query::DoStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_do_stmt();
    _impl_.node_.do_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.do_stmt)
}
inline ::pg_query::DoStmt* Node::_internal_mutable_do_stmt() {
  if (node_case() != kDoStmt) {
    clear_node();
    set_has_do_stmt();
    _impl_.node_.do_stmt_ = CreateMaybeMessage<::pg_query::DoStmt>(GetArena());
  }
  return _impl_.node_.do_stmt_;
}
inline ::pg_query::DoStmt* Node::mutable_do_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DoStmt* _msg = _internal_mutable_do_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.do_stmt)
  return _msg;
}

// .pg_query.InlineCodeBlock inline_code_block = 190 [json_name = "InlineCodeBlock"];
inline bool Node::has_inline_code_block() const {
  return node_case() == kInlineCodeBlock;
}
inline bool Node::_internal_has_inline_code_block() const {
  return node_case() == kInlineCodeBlock;
}
inline void Node::set_has_inline_code_block() {
  _impl_._oneof_case_[0] = kInlineCodeBlock;
}
inline void Node::clear_inline_code_block() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kInlineCodeBlock) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kInlineCodeBlock) {
    clear_has_node();
    auto* temp = _impl_.node_.inline_code_block_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.inline_code_block_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::InlineCodeBlock& Node::_internal_inline_code_block() const {
  return node_case() == kInlineCodeBlock ? *_impl_.node_.inline_code_block_ : reinterpret_cast<::pg_query::InlineCodeBlock&>(::pg_query::_InlineCodeBlock_default_instance_);
}
inline const ::pg_query::InlineCodeBlock& Node::inline_code_block() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kInlineCodeBlock) {
    clear_has_node();
    auto* temp = _impl_.node_.inline_code_block_;
    _impl_.node_.inline_code_block_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_inline_code_block(::pg_query::InlineCodeBlock* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_inline_code_block();
    _impl_.node_.inline_code_block_ = value;
  }
  // @@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 (node_case() != kInlineCodeBlock) {
    clear_node();
    set_has_inline_code_block();
    _impl_.node_.inline_code_block_ = CreateMaybeMessage<::pg_query::InlineCodeBlock>(GetArena());
  }
  return _impl_.node_.inline_code_block_;
}
inline ::pg_query::InlineCodeBlock* Node::mutable_inline_code_block() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::InlineCodeBlock* _msg = _internal_mutable_inline_code_block();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.inline_code_block)
  return _msg;
}

// .pg_query.CallStmt call_stmt = 191 [json_name = "CallStmt"];
inline bool Node::has_call_stmt() const {
  return node_case() == kCallStmt;
}
inline bool Node::_internal_has_call_stmt() const {
  return node_case() == kCallStmt;
}
inline void Node::set_has_call_stmt() {
  _impl_._oneof_case_[0] = kCallStmt;
}
inline void Node::clear_call_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCallStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCallStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.call_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.call_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CallStmt& Node::_internal_call_stmt() const {
  return node_case() == kCallStmt ? *_impl_.node_.call_stmt_ : reinterpret_cast<::pg_query::CallStmt&>(::pg_query::_CallStmt_default_instance_);
}
inline const ::pg_query::CallStmt& Node::call_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCallStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.call_stmt_;
    _impl_.node_.call_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_call_stmt(::pg_query::CallStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_call_stmt();
    _impl_.node_.call_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.call_stmt)
}
inline ::pg_query::CallStmt* Node::_internal_mutable_call_stmt() {
  if (node_case() != kCallStmt) {
    clear_node();
    set_has_call_stmt();
    _impl_.node_.call_stmt_ = CreateMaybeMessage<::pg_query::CallStmt>(GetArena());
  }
  return _impl_.node_.call_stmt_;
}
inline ::pg_query::CallStmt* Node::mutable_call_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CallStmt* _msg = _internal_mutable_call_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.call_stmt)
  return _msg;
}

// .pg_query.CallContext call_context = 192 [json_name = "CallContext"];
inline bool Node::has_call_context() const {
  return node_case() == kCallContext;
}
inline bool Node::_internal_has_call_context() const {
  return node_case() == kCallContext;
}
inline void Node::set_has_call_context() {
  _impl_._oneof_case_[0] = kCallContext;
}
inline void Node::clear_call_context() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCallContext) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCallContext) {
    clear_has_node();
    auto* temp = _impl_.node_.call_context_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.call_context_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CallContext& Node::_internal_call_context() const {
  return node_case() == kCallContext ? *_impl_.node_.call_context_ : reinterpret_cast<::pg_query::CallContext&>(::pg_query::_CallContext_default_instance_);
}
inline const ::pg_query::CallContext& Node::call_context() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCallContext) {
    clear_has_node();
    auto* temp = _impl_.node_.call_context_;
    _impl_.node_.call_context_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_call_context(::pg_query::CallContext* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_call_context();
    _impl_.node_.call_context_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.call_context)
}
inline ::pg_query::CallContext* Node::_internal_mutable_call_context() {
  if (node_case() != kCallContext) {
    clear_node();
    set_has_call_context();
    _impl_.node_.call_context_ = CreateMaybeMessage<::pg_query::CallContext>(GetArena());
  }
  return _impl_.node_.call_context_;
}
inline ::pg_query::CallContext* Node::mutable_call_context() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CallContext* _msg = _internal_mutable_call_context();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.call_context)
  return _msg;
}

// .pg_query.RenameStmt rename_stmt = 193 [json_name = "RenameStmt"];
inline bool Node::has_rename_stmt() const {
  return node_case() == kRenameStmt;
}
inline bool Node::_internal_has_rename_stmt() const {
  return node_case() == kRenameStmt;
}
inline void Node::set_has_rename_stmt() {
  _impl_._oneof_case_[0] = kRenameStmt;
}
inline void Node::clear_rename_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRenameStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRenameStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.rename_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.rename_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RenameStmt& Node::_internal_rename_stmt() const {
  return node_case() == kRenameStmt ? *_impl_.node_.rename_stmt_ : reinterpret_cast<::pg_query::RenameStmt&>(::pg_query::_RenameStmt_default_instance_);
}
inline const ::pg_query::RenameStmt& Node::rename_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRenameStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.rename_stmt_;
    _impl_.node_.rename_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_rename_stmt(::pg_query::RenameStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_rename_stmt();
    _impl_.node_.rename_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.rename_stmt)
}
inline ::pg_query::RenameStmt* Node::_internal_mutable_rename_stmt() {
  if (node_case() != kRenameStmt) {
    clear_node();
    set_has_rename_stmt();
    _impl_.node_.rename_stmt_ = CreateMaybeMessage<::pg_query::RenameStmt>(GetArena());
  }
  return _impl_.node_.rename_stmt_;
}
inline ::pg_query::RenameStmt* Node::mutable_rename_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RenameStmt* _msg = _internal_mutable_rename_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.rename_stmt)
  return _msg;
}

// .pg_query.AlterObjectDependsStmt alter_object_depends_stmt = 194 [json_name = "AlterObjectDependsStmt"];
inline bool Node::has_alter_object_depends_stmt() const {
  return node_case() == kAlterObjectDependsStmt;
}
inline bool Node::_internal_has_alter_object_depends_stmt() const {
  return node_case() == kAlterObjectDependsStmt;
}
inline void Node::set_has_alter_object_depends_stmt() {
  _impl_._oneof_case_[0] = kAlterObjectDependsStmt;
}
inline void Node::clear_alter_object_depends_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterObjectDependsStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterObjectDependsStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_object_depends_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_object_depends_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterObjectDependsStmt& Node::_internal_alter_object_depends_stmt() const {
  return node_case() == kAlterObjectDependsStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterObjectDependsStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_object_depends_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_object_depends_stmt();
    _impl_.node_.alter_object_depends_stmt_ = value;
  }
  // @@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 (node_case() != kAlterObjectDependsStmt) {
    clear_node();
    set_has_alter_object_depends_stmt();
    _impl_.node_.alter_object_depends_stmt_ = CreateMaybeMessage<::pg_query::AlterObjectDependsStmt>(GetArena());
  }
  return _impl_.node_.alter_object_depends_stmt_;
}
inline ::pg_query::AlterObjectDependsStmt* Node::mutable_alter_object_depends_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterObjectDependsStmt* _msg = _internal_mutable_alter_object_depends_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_object_depends_stmt)
  return _msg;
}

// .pg_query.AlterObjectSchemaStmt alter_object_schema_stmt = 195 [json_name = "AlterObjectSchemaStmt"];
inline bool Node::has_alter_object_schema_stmt() const {
  return node_case() == kAlterObjectSchemaStmt;
}
inline bool Node::_internal_has_alter_object_schema_stmt() const {
  return node_case() == kAlterObjectSchemaStmt;
}
inline void Node::set_has_alter_object_schema_stmt() {
  _impl_._oneof_case_[0] = kAlterObjectSchemaStmt;
}
inline void Node::clear_alter_object_schema_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterObjectSchemaStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterObjectSchemaStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_object_schema_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_object_schema_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterObjectSchemaStmt& Node::_internal_alter_object_schema_stmt() const {
  return node_case() == kAlterObjectSchemaStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterObjectSchemaStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_object_schema_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_object_schema_stmt();
    _impl_.node_.alter_object_schema_stmt_ = value;
  }
  // @@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 (node_case() != kAlterObjectSchemaStmt) {
    clear_node();
    set_has_alter_object_schema_stmt();
    _impl_.node_.alter_object_schema_stmt_ = CreateMaybeMessage<::pg_query::AlterObjectSchemaStmt>(GetArena());
  }
  return _impl_.node_.alter_object_schema_stmt_;
}
inline ::pg_query::AlterObjectSchemaStmt* Node::mutable_alter_object_schema_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterObjectSchemaStmt* _msg = _internal_mutable_alter_object_schema_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_object_schema_stmt)
  return _msg;
}

// .pg_query.AlterOwnerStmt alter_owner_stmt = 196 [json_name = "AlterOwnerStmt"];
inline bool Node::has_alter_owner_stmt() const {
  return node_case() == kAlterOwnerStmt;
}
inline bool Node::_internal_has_alter_owner_stmt() const {
  return node_case() == kAlterOwnerStmt;
}
inline void Node::set_has_alter_owner_stmt() {
  _impl_._oneof_case_[0] = kAlterOwnerStmt;
}
inline void Node::clear_alter_owner_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterOwnerStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterOwnerStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_owner_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_owner_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterOwnerStmt& Node::_internal_alter_owner_stmt() const {
  return node_case() == kAlterOwnerStmt ? *_impl_.node_.alter_owner_stmt_ : reinterpret_cast<::pg_query::AlterOwnerStmt&>(::pg_query::_AlterOwnerStmt_default_instance_);
}
inline const ::pg_query::AlterOwnerStmt& Node::alter_owner_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterOwnerStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_owner_stmt_;
    _impl_.node_.alter_owner_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_owner_stmt(::pg_query::AlterOwnerStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_owner_stmt();
    _impl_.node_.alter_owner_stmt_ = value;
  }
  // @@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 (node_case() != kAlterOwnerStmt) {
    clear_node();
    set_has_alter_owner_stmt();
    _impl_.node_.alter_owner_stmt_ = CreateMaybeMessage<::pg_query::AlterOwnerStmt>(GetArena());
  }
  return _impl_.node_.alter_owner_stmt_;
}
inline ::pg_query::AlterOwnerStmt* Node::mutable_alter_owner_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterOwnerStmt* _msg = _internal_mutable_alter_owner_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_owner_stmt)
  return _msg;
}

// .pg_query.AlterOperatorStmt alter_operator_stmt = 197 [json_name = "AlterOperatorStmt"];
inline bool Node::has_alter_operator_stmt() const {
  return node_case() == kAlterOperatorStmt;
}
inline bool Node::_internal_has_alter_operator_stmt() const {
  return node_case() == kAlterOperatorStmt;
}
inline void Node::set_has_alter_operator_stmt() {
  _impl_._oneof_case_[0] = kAlterOperatorStmt;
}
inline void Node::clear_alter_operator_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterOperatorStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterOperatorStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_operator_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_operator_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterOperatorStmt& Node::_internal_alter_operator_stmt() const {
  return node_case() == kAlterOperatorStmt ? *_impl_.node_.alter_operator_stmt_ : reinterpret_cast<::pg_query::AlterOperatorStmt&>(::pg_query::_AlterOperatorStmt_default_instance_);
}
inline const ::pg_query::AlterOperatorStmt& Node::alter_operator_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterOperatorStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_operator_stmt_;
    _impl_.node_.alter_operator_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_operator_stmt(::pg_query::AlterOperatorStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_operator_stmt();
    _impl_.node_.alter_operator_stmt_ = value;
  }
  // @@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 (node_case() != kAlterOperatorStmt) {
    clear_node();
    set_has_alter_operator_stmt();
    _impl_.node_.alter_operator_stmt_ = CreateMaybeMessage<::pg_query::AlterOperatorStmt>(GetArena());
  }
  return _impl_.node_.alter_operator_stmt_;
}
inline ::pg_query::AlterOperatorStmt* Node::mutable_alter_operator_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterOperatorStmt* _msg = _internal_mutable_alter_operator_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_operator_stmt)
  return _msg;
}

// .pg_query.AlterTypeStmt alter_type_stmt = 198 [json_name = "AlterTypeStmt"];
inline bool Node::has_alter_type_stmt() const {
  return node_case() == kAlterTypeStmt;
}
inline bool Node::_internal_has_alter_type_stmt() const {
  return node_case() == kAlterTypeStmt;
}
inline void Node::set_has_alter_type_stmt() {
  _impl_._oneof_case_[0] = kAlterTypeStmt;
}
inline void Node::clear_alter_type_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterTypeStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterTypeStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_type_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_type_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterTypeStmt& Node::_internal_alter_type_stmt() const {
  return node_case() == kAlterTypeStmt ? *_impl_.node_.alter_type_stmt_ : reinterpret_cast<::pg_query::AlterTypeStmt&>(::pg_query::_AlterTypeStmt_default_instance_);
}
inline const ::pg_query::AlterTypeStmt& Node::alter_type_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterTypeStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_type_stmt_;
    _impl_.node_.alter_type_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_type_stmt(::pg_query::AlterTypeStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_type_stmt();
    _impl_.node_.alter_type_stmt_ = value;
  }
  // @@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 (node_case() != kAlterTypeStmt) {
    clear_node();
    set_has_alter_type_stmt();
    _impl_.node_.alter_type_stmt_ = CreateMaybeMessage<::pg_query::AlterTypeStmt>(GetArena());
  }
  return _impl_.node_.alter_type_stmt_;
}
inline ::pg_query::AlterTypeStmt* Node::mutable_alter_type_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterTypeStmt* _msg = _internal_mutable_alter_type_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_type_stmt)
  return _msg;
}

// .pg_query.RuleStmt rule_stmt = 199 [json_name = "RuleStmt"];
inline bool Node::has_rule_stmt() const {
  return node_case() == kRuleStmt;
}
inline bool Node::_internal_has_rule_stmt() const {
  return node_case() == kRuleStmt;
}
inline void Node::set_has_rule_stmt() {
  _impl_._oneof_case_[0] = kRuleStmt;
}
inline void Node::clear_rule_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRuleStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRuleStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.rule_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.rule_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RuleStmt& Node::_internal_rule_stmt() const {
  return node_case() == kRuleStmt ? *_impl_.node_.rule_stmt_ : reinterpret_cast<::pg_query::RuleStmt&>(::pg_query::_RuleStmt_default_instance_);
}
inline const ::pg_query::RuleStmt& Node::rule_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRuleStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.rule_stmt_;
    _impl_.node_.rule_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_rule_stmt(::pg_query::RuleStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_rule_stmt();
    _impl_.node_.rule_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.rule_stmt)
}
inline ::pg_query::RuleStmt* Node::_internal_mutable_rule_stmt() {
  if (node_case() != kRuleStmt) {
    clear_node();
    set_has_rule_stmt();
    _impl_.node_.rule_stmt_ = CreateMaybeMessage<::pg_query::RuleStmt>(GetArena());
  }
  return _impl_.node_.rule_stmt_;
}
inline ::pg_query::RuleStmt* Node::mutable_rule_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RuleStmt* _msg = _internal_mutable_rule_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.rule_stmt)
  return _msg;
}

// .pg_query.NotifyStmt notify_stmt = 200 [json_name = "NotifyStmt"];
inline bool Node::has_notify_stmt() const {
  return node_case() == kNotifyStmt;
}
inline bool Node::_internal_has_notify_stmt() const {
  return node_case() == kNotifyStmt;
}
inline void Node::set_has_notify_stmt() {
  _impl_._oneof_case_[0] = kNotifyStmt;
}
inline void Node::clear_notify_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kNotifyStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kNotifyStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.notify_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.notify_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::NotifyStmt& Node::_internal_notify_stmt() const {
  return node_case() == kNotifyStmt ? *_impl_.node_.notify_stmt_ : reinterpret_cast<::pg_query::NotifyStmt&>(::pg_query::_NotifyStmt_default_instance_);
}
inline const ::pg_query::NotifyStmt& Node::notify_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kNotifyStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.notify_stmt_;
    _impl_.node_.notify_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_notify_stmt(::pg_query::NotifyStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_notify_stmt();
    _impl_.node_.notify_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.notify_stmt)
}
inline ::pg_query::NotifyStmt* Node::_internal_mutable_notify_stmt() {
  if (node_case() != kNotifyStmt) {
    clear_node();
    set_has_notify_stmt();
    _impl_.node_.notify_stmt_ = CreateMaybeMessage<::pg_query::NotifyStmt>(GetArena());
  }
  return _impl_.node_.notify_stmt_;
}
inline ::pg_query::NotifyStmt* Node::mutable_notify_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::NotifyStmt* _msg = _internal_mutable_notify_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.notify_stmt)
  return _msg;
}

// .pg_query.ListenStmt listen_stmt = 201 [json_name = "ListenStmt"];
inline bool Node::has_listen_stmt() const {
  return node_case() == kListenStmt;
}
inline bool Node::_internal_has_listen_stmt() const {
  return node_case() == kListenStmt;
}
inline void Node::set_has_listen_stmt() {
  _impl_._oneof_case_[0] = kListenStmt;
}
inline void Node::clear_listen_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kListenStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kListenStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.listen_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.listen_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ListenStmt& Node::_internal_listen_stmt() const {
  return node_case() == kListenStmt ? *_impl_.node_.listen_stmt_ : reinterpret_cast<::pg_query::ListenStmt&>(::pg_query::_ListenStmt_default_instance_);
}
inline const ::pg_query::ListenStmt& Node::listen_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kListenStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.listen_stmt_;
    _impl_.node_.listen_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_listen_stmt(::pg_query::ListenStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_listen_stmt();
    _impl_.node_.listen_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.listen_stmt)
}
inline ::pg_query::ListenStmt* Node::_internal_mutable_listen_stmt() {
  if (node_case() != kListenStmt) {
    clear_node();
    set_has_listen_stmt();
    _impl_.node_.listen_stmt_ = CreateMaybeMessage<::pg_query::ListenStmt>(GetArena());
  }
  return _impl_.node_.listen_stmt_;
}
inline ::pg_query::ListenStmt* Node::mutable_listen_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ListenStmt* _msg = _internal_mutable_listen_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.listen_stmt)
  return _msg;
}

// .pg_query.UnlistenStmt unlisten_stmt = 202 [json_name = "UnlistenStmt"];
inline bool Node::has_unlisten_stmt() const {
  return node_case() == kUnlistenStmt;
}
inline bool Node::_internal_has_unlisten_stmt() const {
  return node_case() == kUnlistenStmt;
}
inline void Node::set_has_unlisten_stmt() {
  _impl_._oneof_case_[0] = kUnlistenStmt;
}
inline void Node::clear_unlisten_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kUnlistenStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kUnlistenStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.unlisten_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.unlisten_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::UnlistenStmt& Node::_internal_unlisten_stmt() const {
  return node_case() == kUnlistenStmt ? *_impl_.node_.unlisten_stmt_ : reinterpret_cast<::pg_query::UnlistenStmt&>(::pg_query::_UnlistenStmt_default_instance_);
}
inline const ::pg_query::UnlistenStmt& Node::unlisten_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kUnlistenStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.unlisten_stmt_;
    _impl_.node_.unlisten_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_unlisten_stmt(::pg_query::UnlistenStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_unlisten_stmt();
    _impl_.node_.unlisten_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.unlisten_stmt)
}
inline ::pg_query::UnlistenStmt* Node::_internal_mutable_unlisten_stmt() {
  if (node_case() != kUnlistenStmt) {
    clear_node();
    set_has_unlisten_stmt();
    _impl_.node_.unlisten_stmt_ = CreateMaybeMessage<::pg_query::UnlistenStmt>(GetArena());
  }
  return _impl_.node_.unlisten_stmt_;
}
inline ::pg_query::UnlistenStmt* Node::mutable_unlisten_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::UnlistenStmt* _msg = _internal_mutable_unlisten_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.unlisten_stmt)
  return _msg;
}

// .pg_query.TransactionStmt transaction_stmt = 203 [json_name = "TransactionStmt"];
inline bool Node::has_transaction_stmt() const {
  return node_case() == kTransactionStmt;
}
inline bool Node::_internal_has_transaction_stmt() const {
  return node_case() == kTransactionStmt;
}
inline void Node::set_has_transaction_stmt() {
  _impl_._oneof_case_[0] = kTransactionStmt;
}
inline void Node::clear_transaction_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kTransactionStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kTransactionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.transaction_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.transaction_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::TransactionStmt& Node::_internal_transaction_stmt() const {
  return node_case() == kTransactionStmt ? *_impl_.node_.transaction_stmt_ : reinterpret_cast<::pg_query::TransactionStmt&>(::pg_query::_TransactionStmt_default_instance_);
}
inline const ::pg_query::TransactionStmt& Node::transaction_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kTransactionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.transaction_stmt_;
    _impl_.node_.transaction_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_transaction_stmt(::pg_query::TransactionStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_transaction_stmt();
    _impl_.node_.transaction_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.transaction_stmt)
}
inline ::pg_query::TransactionStmt* Node::_internal_mutable_transaction_stmt() {
  if (node_case() != kTransactionStmt) {
    clear_node();
    set_has_transaction_stmt();
    _impl_.node_.transaction_stmt_ = CreateMaybeMessage<::pg_query::TransactionStmt>(GetArena());
  }
  return _impl_.node_.transaction_stmt_;
}
inline ::pg_query::TransactionStmt* Node::mutable_transaction_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TransactionStmt* _msg = _internal_mutable_transaction_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.transaction_stmt)
  return _msg;
}

// .pg_query.CompositeTypeStmt composite_type_stmt = 204 [json_name = "CompositeTypeStmt"];
inline bool Node::has_composite_type_stmt() const {
  return node_case() == kCompositeTypeStmt;
}
inline bool Node::_internal_has_composite_type_stmt() const {
  return node_case() == kCompositeTypeStmt;
}
inline void Node::set_has_composite_type_stmt() {
  _impl_._oneof_case_[0] = kCompositeTypeStmt;
}
inline void Node::clear_composite_type_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCompositeTypeStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCompositeTypeStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.composite_type_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.composite_type_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CompositeTypeStmt& Node::_internal_composite_type_stmt() const {
  return node_case() == kCompositeTypeStmt ? *_impl_.node_.composite_type_stmt_ : reinterpret_cast<::pg_query::CompositeTypeStmt&>(::pg_query::_CompositeTypeStmt_default_instance_);
}
inline const ::pg_query::CompositeTypeStmt& Node::composite_type_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCompositeTypeStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.composite_type_stmt_;
    _impl_.node_.composite_type_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_composite_type_stmt(::pg_query::CompositeTypeStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_composite_type_stmt();
    _impl_.node_.composite_type_stmt_ = value;
  }
  // @@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 (node_case() != kCompositeTypeStmt) {
    clear_node();
    set_has_composite_type_stmt();
    _impl_.node_.composite_type_stmt_ = CreateMaybeMessage<::pg_query::CompositeTypeStmt>(GetArena());
  }
  return _impl_.node_.composite_type_stmt_;
}
inline ::pg_query::CompositeTypeStmt* Node::mutable_composite_type_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CompositeTypeStmt* _msg = _internal_mutable_composite_type_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.composite_type_stmt)
  return _msg;
}

// .pg_query.CreateEnumStmt create_enum_stmt = 205 [json_name = "CreateEnumStmt"];
inline bool Node::has_create_enum_stmt() const {
  return node_case() == kCreateEnumStmt;
}
inline bool Node::_internal_has_create_enum_stmt() const {
  return node_case() == kCreateEnumStmt;
}
inline void Node::set_has_create_enum_stmt() {
  _impl_._oneof_case_[0] = kCreateEnumStmt;
}
inline void Node::clear_create_enum_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateEnumStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateEnumStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_enum_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_enum_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateEnumStmt& Node::_internal_create_enum_stmt() const {
  return node_case() == kCreateEnumStmt ? *_impl_.node_.create_enum_stmt_ : reinterpret_cast<::pg_query::CreateEnumStmt&>(::pg_query::_CreateEnumStmt_default_instance_);
}
inline const ::pg_query::CreateEnumStmt& Node::create_enum_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateEnumStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_enum_stmt_;
    _impl_.node_.create_enum_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_enum_stmt(::pg_query::CreateEnumStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_enum_stmt();
    _impl_.node_.create_enum_stmt_ = value;
  }
  // @@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 (node_case() != kCreateEnumStmt) {
    clear_node();
    set_has_create_enum_stmt();
    _impl_.node_.create_enum_stmt_ = CreateMaybeMessage<::pg_query::CreateEnumStmt>(GetArena());
  }
  return _impl_.node_.create_enum_stmt_;
}
inline ::pg_query::CreateEnumStmt* Node::mutable_create_enum_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateEnumStmt* _msg = _internal_mutable_create_enum_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_enum_stmt)
  return _msg;
}

// .pg_query.CreateRangeStmt create_range_stmt = 206 [json_name = "CreateRangeStmt"];
inline bool Node::has_create_range_stmt() const {
  return node_case() == kCreateRangeStmt;
}
inline bool Node::_internal_has_create_range_stmt() const {
  return node_case() == kCreateRangeStmt;
}
inline void Node::set_has_create_range_stmt() {
  _impl_._oneof_case_[0] = kCreateRangeStmt;
}
inline void Node::clear_create_range_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateRangeStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateRangeStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_range_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_range_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateRangeStmt& Node::_internal_create_range_stmt() const {
  return node_case() == kCreateRangeStmt ? *_impl_.node_.create_range_stmt_ : reinterpret_cast<::pg_query::CreateRangeStmt&>(::pg_query::_CreateRangeStmt_default_instance_);
}
inline const ::pg_query::CreateRangeStmt& Node::create_range_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateRangeStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_range_stmt_;
    _impl_.node_.create_range_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_range_stmt(::pg_query::CreateRangeStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_range_stmt();
    _impl_.node_.create_range_stmt_ = value;
  }
  // @@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 (node_case() != kCreateRangeStmt) {
    clear_node();
    set_has_create_range_stmt();
    _impl_.node_.create_range_stmt_ = CreateMaybeMessage<::pg_query::CreateRangeStmt>(GetArena());
  }
  return _impl_.node_.create_range_stmt_;
}
inline ::pg_query::CreateRangeStmt* Node::mutable_create_range_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateRangeStmt* _msg = _internal_mutable_create_range_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_range_stmt)
  return _msg;
}

// .pg_query.AlterEnumStmt alter_enum_stmt = 207 [json_name = "AlterEnumStmt"];
inline bool Node::has_alter_enum_stmt() const {
  return node_case() == kAlterEnumStmt;
}
inline bool Node::_internal_has_alter_enum_stmt() const {
  return node_case() == kAlterEnumStmt;
}
inline void Node::set_has_alter_enum_stmt() {
  _impl_._oneof_case_[0] = kAlterEnumStmt;
}
inline void Node::clear_alter_enum_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterEnumStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterEnumStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_enum_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_enum_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterEnumStmt& Node::_internal_alter_enum_stmt() const {
  return node_case() == kAlterEnumStmt ? *_impl_.node_.alter_enum_stmt_ : reinterpret_cast<::pg_query::AlterEnumStmt&>(::pg_query::_AlterEnumStmt_default_instance_);
}
inline const ::pg_query::AlterEnumStmt& Node::alter_enum_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterEnumStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_enum_stmt_;
    _impl_.node_.alter_enum_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_enum_stmt(::pg_query::AlterEnumStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_enum_stmt();
    _impl_.node_.alter_enum_stmt_ = value;
  }
  // @@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 (node_case() != kAlterEnumStmt) {
    clear_node();
    set_has_alter_enum_stmt();
    _impl_.node_.alter_enum_stmt_ = CreateMaybeMessage<::pg_query::AlterEnumStmt>(GetArena());
  }
  return _impl_.node_.alter_enum_stmt_;
}
inline ::pg_query::AlterEnumStmt* Node::mutable_alter_enum_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterEnumStmt* _msg = _internal_mutable_alter_enum_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_enum_stmt)
  return _msg;
}

// .pg_query.ViewStmt view_stmt = 208 [json_name = "ViewStmt"];
inline bool Node::has_view_stmt() const {
  return node_case() == kViewStmt;
}
inline bool Node::_internal_has_view_stmt() const {
  return node_case() == kViewStmt;
}
inline void Node::set_has_view_stmt() {
  _impl_._oneof_case_[0] = kViewStmt;
}
inline void Node::clear_view_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kViewStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kViewStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.view_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.view_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ViewStmt& Node::_internal_view_stmt() const {
  return node_case() == kViewStmt ? *_impl_.node_.view_stmt_ : reinterpret_cast<::pg_query::ViewStmt&>(::pg_query::_ViewStmt_default_instance_);
}
inline const ::pg_query::ViewStmt& Node::view_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kViewStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.view_stmt_;
    _impl_.node_.view_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_view_stmt(::pg_query::ViewStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_view_stmt();
    _impl_.node_.view_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.view_stmt)
}
inline ::pg_query::ViewStmt* Node::_internal_mutable_view_stmt() {
  if (node_case() != kViewStmt) {
    clear_node();
    set_has_view_stmt();
    _impl_.node_.view_stmt_ = CreateMaybeMessage<::pg_query::ViewStmt>(GetArena());
  }
  return _impl_.node_.view_stmt_;
}
inline ::pg_query::ViewStmt* Node::mutable_view_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ViewStmt* _msg = _internal_mutable_view_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.view_stmt)
  return _msg;
}

// .pg_query.LoadStmt load_stmt = 209 [json_name = "LoadStmt"];
inline bool Node::has_load_stmt() const {
  return node_case() == kLoadStmt;
}
inline bool Node::_internal_has_load_stmt() const {
  return node_case() == kLoadStmt;
}
inline void Node::set_has_load_stmt() {
  _impl_._oneof_case_[0] = kLoadStmt;
}
inline void Node::clear_load_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kLoadStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kLoadStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.load_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.load_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::LoadStmt& Node::_internal_load_stmt() const {
  return node_case() == kLoadStmt ? *_impl_.node_.load_stmt_ : reinterpret_cast<::pg_query::LoadStmt&>(::pg_query::_LoadStmt_default_instance_);
}
inline const ::pg_query::LoadStmt& Node::load_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kLoadStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.load_stmt_;
    _impl_.node_.load_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_load_stmt(::pg_query::LoadStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_load_stmt();
    _impl_.node_.load_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.load_stmt)
}
inline ::pg_query::LoadStmt* Node::_internal_mutable_load_stmt() {
  if (node_case() != kLoadStmt) {
    clear_node();
    set_has_load_stmt();
    _impl_.node_.load_stmt_ = CreateMaybeMessage<::pg_query::LoadStmt>(GetArena());
  }
  return _impl_.node_.load_stmt_;
}
inline ::pg_query::LoadStmt* Node::mutable_load_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::LoadStmt* _msg = _internal_mutable_load_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.load_stmt)
  return _msg;
}

// .pg_query.CreatedbStmt createdb_stmt = 210 [json_name = "CreatedbStmt"];
inline bool Node::has_createdb_stmt() const {
  return node_case() == kCreatedbStmt;
}
inline bool Node::_internal_has_createdb_stmt() const {
  return node_case() == kCreatedbStmt;
}
inline void Node::set_has_createdb_stmt() {
  _impl_._oneof_case_[0] = kCreatedbStmt;
}
inline void Node::clear_createdb_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreatedbStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreatedbStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.createdb_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.createdb_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreatedbStmt& Node::_internal_createdb_stmt() const {
  return node_case() == kCreatedbStmt ? *_impl_.node_.createdb_stmt_ : reinterpret_cast<::pg_query::CreatedbStmt&>(::pg_query::_CreatedbStmt_default_instance_);
}
inline const ::pg_query::CreatedbStmt& Node::createdb_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreatedbStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.createdb_stmt_;
    _impl_.node_.createdb_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_createdb_stmt(::pg_query::CreatedbStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_createdb_stmt();
    _impl_.node_.createdb_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.createdb_stmt)
}
inline ::pg_query::CreatedbStmt* Node::_internal_mutable_createdb_stmt() {
  if (node_case() != kCreatedbStmt) {
    clear_node();
    set_has_createdb_stmt();
    _impl_.node_.createdb_stmt_ = CreateMaybeMessage<::pg_query::CreatedbStmt>(GetArena());
  }
  return _impl_.node_.createdb_stmt_;
}
inline ::pg_query::CreatedbStmt* Node::mutable_createdb_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreatedbStmt* _msg = _internal_mutable_createdb_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.createdb_stmt)
  return _msg;
}

// .pg_query.AlterDatabaseStmt alter_database_stmt = 211 [json_name = "AlterDatabaseStmt"];
inline bool Node::has_alter_database_stmt() const {
  return node_case() == kAlterDatabaseStmt;
}
inline bool Node::_internal_has_alter_database_stmt() const {
  return node_case() == kAlterDatabaseStmt;
}
inline void Node::set_has_alter_database_stmt() {
  _impl_._oneof_case_[0] = kAlterDatabaseStmt;
}
inline void Node::clear_alter_database_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterDatabaseStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterDatabaseStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_database_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_database_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterDatabaseStmt& Node::_internal_alter_database_stmt() const {
  return node_case() == kAlterDatabaseStmt ? *_impl_.node_.alter_database_stmt_ : reinterpret_cast<::pg_query::AlterDatabaseStmt&>(::pg_query::_AlterDatabaseStmt_default_instance_);
}
inline const ::pg_query::AlterDatabaseStmt& Node::alter_database_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterDatabaseStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_database_stmt_;
    _impl_.node_.alter_database_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_database_stmt(::pg_query::AlterDatabaseStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_database_stmt();
    _impl_.node_.alter_database_stmt_ = value;
  }
  // @@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 (node_case() != kAlterDatabaseStmt) {
    clear_node();
    set_has_alter_database_stmt();
    _impl_.node_.alter_database_stmt_ = CreateMaybeMessage<::pg_query::AlterDatabaseStmt>(GetArena());
  }
  return _impl_.node_.alter_database_stmt_;
}
inline ::pg_query::AlterDatabaseStmt* Node::mutable_alter_database_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterDatabaseStmt* _msg = _internal_mutable_alter_database_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_database_stmt)
  return _msg;
}

// .pg_query.AlterDatabaseRefreshCollStmt alter_database_refresh_coll_stmt = 212 [json_name = "AlterDatabaseRefreshCollStmt"];
inline bool Node::has_alter_database_refresh_coll_stmt() const {
  return node_case() == kAlterDatabaseRefreshCollStmt;
}
inline bool Node::_internal_has_alter_database_refresh_coll_stmt() const {
  return node_case() == kAlterDatabaseRefreshCollStmt;
}
inline void Node::set_has_alter_database_refresh_coll_stmt() {
  _impl_._oneof_case_[0] = kAlterDatabaseRefreshCollStmt;
}
inline void Node::clear_alter_database_refresh_coll_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterDatabaseRefreshCollStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.alter_database_refresh_coll_stmt_;
    }
    clear_has_node();
  }
}
inline ::pg_query::AlterDatabaseRefreshCollStmt* Node::release_alter_database_refresh_coll_stmt() {
  // @@protoc_insertion_point(field_release:pg_query.Node.alter_database_refresh_coll_stmt)
  if (node_case() == kAlterDatabaseRefreshCollStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_database_refresh_coll_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_database_refresh_coll_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterDatabaseRefreshCollStmt& Node::_internal_alter_database_refresh_coll_stmt() const {
  return node_case() == kAlterDatabaseRefreshCollStmt ? *_impl_.node_.alter_database_refresh_coll_stmt_ : reinterpret_cast<::pg_query::AlterDatabaseRefreshCollStmt&>(::pg_query::_AlterDatabaseRefreshCollStmt_default_instance_);
}
inline const ::pg_query::AlterDatabaseRefreshCollStmt& Node::alter_database_refresh_coll_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.alter_database_refresh_coll_stmt)
  return _internal_alter_database_refresh_coll_stmt();
}
inline ::pg_query::AlterDatabaseRefreshCollStmt* Node::unsafe_arena_release_alter_database_refresh_coll_stmt() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_database_refresh_coll_stmt)
  if (node_case() == kAlterDatabaseRefreshCollStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_database_refresh_coll_stmt_;
    _impl_.node_.alter_database_refresh_coll_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_database_refresh_coll_stmt(::pg_query::AlterDatabaseRefreshCollStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_database_refresh_coll_stmt();
    _impl_.node_.alter_database_refresh_coll_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_database_refresh_coll_stmt)
}
inline ::pg_query::AlterDatabaseRefreshCollStmt* Node::_internal_mutable_alter_database_refresh_coll_stmt() {
  if (node_case() != kAlterDatabaseRefreshCollStmt) {
    clear_node();
    set_has_alter_database_refresh_coll_stmt();
    _impl_.node_.alter_database_refresh_coll_stmt_ = CreateMaybeMessage<::pg_query::AlterDatabaseRefreshCollStmt>(GetArena());
  }
  return _impl_.node_.alter_database_refresh_coll_stmt_;
}
inline ::pg_query::AlterDatabaseRefreshCollStmt* Node::mutable_alter_database_refresh_coll_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterDatabaseRefreshCollStmt* _msg = _internal_mutable_alter_database_refresh_coll_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_database_refresh_coll_stmt)
  return _msg;
}

// .pg_query.AlterDatabaseSetStmt alter_database_set_stmt = 213 [json_name = "AlterDatabaseSetStmt"];
inline bool Node::has_alter_database_set_stmt() const {
  return node_case() == kAlterDatabaseSetStmt;
}
inline bool Node::_internal_has_alter_database_set_stmt() const {
  return node_case() == kAlterDatabaseSetStmt;
}
inline void Node::set_has_alter_database_set_stmt() {
  _impl_._oneof_case_[0] = kAlterDatabaseSetStmt;
}
inline void Node::clear_alter_database_set_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterDatabaseSetStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterDatabaseSetStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_database_set_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_database_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterDatabaseSetStmt& Node::_internal_alter_database_set_stmt() const {
  return node_case() == kAlterDatabaseSetStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterDatabaseSetStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_database_set_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_database_set_stmt();
    _impl_.node_.alter_database_set_stmt_ = value;
  }
  // @@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 (node_case() != kAlterDatabaseSetStmt) {
    clear_node();
    set_has_alter_database_set_stmt();
    _impl_.node_.alter_database_set_stmt_ = CreateMaybeMessage<::pg_query::AlterDatabaseSetStmt>(GetArena());
  }
  return _impl_.node_.alter_database_set_stmt_;
}
inline ::pg_query::AlterDatabaseSetStmt* Node::mutable_alter_database_set_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterDatabaseSetStmt* _msg = _internal_mutable_alter_database_set_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_database_set_stmt)
  return _msg;
}

// .pg_query.DropdbStmt dropdb_stmt = 214 [json_name = "DropdbStmt"];
inline bool Node::has_dropdb_stmt() const {
  return node_case() == kDropdbStmt;
}
inline bool Node::_internal_has_dropdb_stmt() const {
  return node_case() == kDropdbStmt;
}
inline void Node::set_has_dropdb_stmt() {
  _impl_._oneof_case_[0] = kDropdbStmt;
}
inline void Node::clear_dropdb_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDropdbStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDropdbStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.dropdb_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.dropdb_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropdbStmt& Node::_internal_dropdb_stmt() const {
  return node_case() == kDropdbStmt ? *_impl_.node_.dropdb_stmt_ : reinterpret_cast<::pg_query::DropdbStmt&>(::pg_query::_DropdbStmt_default_instance_);
}
inline const ::pg_query::DropdbStmt& Node::dropdb_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDropdbStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.dropdb_stmt_;
    _impl_.node_.dropdb_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_dropdb_stmt(::pg_query::DropdbStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_dropdb_stmt();
    _impl_.node_.dropdb_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.dropdb_stmt)
}
inline ::pg_query::DropdbStmt* Node::_internal_mutable_dropdb_stmt() {
  if (node_case() != kDropdbStmt) {
    clear_node();
    set_has_dropdb_stmt();
    _impl_.node_.dropdb_stmt_ = CreateMaybeMessage<::pg_query::DropdbStmt>(GetArena());
  }
  return _impl_.node_.dropdb_stmt_;
}
inline ::pg_query::DropdbStmt* Node::mutable_dropdb_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DropdbStmt* _msg = _internal_mutable_dropdb_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.dropdb_stmt)
  return _msg;
}

// .pg_query.AlterSystemStmt alter_system_stmt = 215 [json_name = "AlterSystemStmt"];
inline bool Node::has_alter_system_stmt() const {
  return node_case() == kAlterSystemStmt;
}
inline bool Node::_internal_has_alter_system_stmt() const {
  return node_case() == kAlterSystemStmt;
}
inline void Node::set_has_alter_system_stmt() {
  _impl_._oneof_case_[0] = kAlterSystemStmt;
}
inline void Node::clear_alter_system_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterSystemStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterSystemStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_system_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_system_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterSystemStmt& Node::_internal_alter_system_stmt() const {
  return node_case() == kAlterSystemStmt ? *_impl_.node_.alter_system_stmt_ : reinterpret_cast<::pg_query::AlterSystemStmt&>(::pg_query::_AlterSystemStmt_default_instance_);
}
inline const ::pg_query::AlterSystemStmt& Node::alter_system_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterSystemStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_system_stmt_;
    _impl_.node_.alter_system_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_system_stmt(::pg_query::AlterSystemStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_system_stmt();
    _impl_.node_.alter_system_stmt_ = value;
  }
  // @@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 (node_case() != kAlterSystemStmt) {
    clear_node();
    set_has_alter_system_stmt();
    _impl_.node_.alter_system_stmt_ = CreateMaybeMessage<::pg_query::AlterSystemStmt>(GetArena());
  }
  return _impl_.node_.alter_system_stmt_;
}
inline ::pg_query::AlterSystemStmt* Node::mutable_alter_system_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterSystemStmt* _msg = _internal_mutable_alter_system_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_system_stmt)
  return _msg;
}

// .pg_query.ClusterStmt cluster_stmt = 216 [json_name = "ClusterStmt"];
inline bool Node::has_cluster_stmt() const {
  return node_case() == kClusterStmt;
}
inline bool Node::_internal_has_cluster_stmt() const {
  return node_case() == kClusterStmt;
}
inline void Node::set_has_cluster_stmt() {
  _impl_._oneof_case_[0] = kClusterStmt;
}
inline void Node::clear_cluster_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kClusterStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kClusterStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.cluster_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.cluster_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ClusterStmt& Node::_internal_cluster_stmt() const {
  return node_case() == kClusterStmt ? *_impl_.node_.cluster_stmt_ : reinterpret_cast<::pg_query::ClusterStmt&>(::pg_query::_ClusterStmt_default_instance_);
}
inline const ::pg_query::ClusterStmt& Node::cluster_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kClusterStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.cluster_stmt_;
    _impl_.node_.cluster_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_cluster_stmt(::pg_query::ClusterStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_cluster_stmt();
    _impl_.node_.cluster_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.cluster_stmt)
}
inline ::pg_query::ClusterStmt* Node::_internal_mutable_cluster_stmt() {
  if (node_case() != kClusterStmt) {
    clear_node();
    set_has_cluster_stmt();
    _impl_.node_.cluster_stmt_ = CreateMaybeMessage<::pg_query::ClusterStmt>(GetArena());
  }
  return _impl_.node_.cluster_stmt_;
}
inline ::pg_query::ClusterStmt* Node::mutable_cluster_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ClusterStmt* _msg = _internal_mutable_cluster_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.cluster_stmt)
  return _msg;
}

// .pg_query.VacuumStmt vacuum_stmt = 217 [json_name = "VacuumStmt"];
inline bool Node::has_vacuum_stmt() const {
  return node_case() == kVacuumStmt;
}
inline bool Node::_internal_has_vacuum_stmt() const {
  return node_case() == kVacuumStmt;
}
inline void Node::set_has_vacuum_stmt() {
  _impl_._oneof_case_[0] = kVacuumStmt;
}
inline void Node::clear_vacuum_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kVacuumStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kVacuumStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.vacuum_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.vacuum_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::VacuumStmt& Node::_internal_vacuum_stmt() const {
  return node_case() == kVacuumStmt ? *_impl_.node_.vacuum_stmt_ : reinterpret_cast<::pg_query::VacuumStmt&>(::pg_query::_VacuumStmt_default_instance_);
}
inline const ::pg_query::VacuumStmt& Node::vacuum_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kVacuumStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.vacuum_stmt_;
    _impl_.node_.vacuum_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_vacuum_stmt(::pg_query::VacuumStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_vacuum_stmt();
    _impl_.node_.vacuum_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.vacuum_stmt)
}
inline ::pg_query::VacuumStmt* Node::_internal_mutable_vacuum_stmt() {
  if (node_case() != kVacuumStmt) {
    clear_node();
    set_has_vacuum_stmt();
    _impl_.node_.vacuum_stmt_ = CreateMaybeMessage<::pg_query::VacuumStmt>(GetArena());
  }
  return _impl_.node_.vacuum_stmt_;
}
inline ::pg_query::VacuumStmt* Node::mutable_vacuum_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::VacuumStmt* _msg = _internal_mutable_vacuum_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.vacuum_stmt)
  return _msg;
}

// .pg_query.VacuumRelation vacuum_relation = 218 [json_name = "VacuumRelation"];
inline bool Node::has_vacuum_relation() const {
  return node_case() == kVacuumRelation;
}
inline bool Node::_internal_has_vacuum_relation() const {
  return node_case() == kVacuumRelation;
}
inline void Node::set_has_vacuum_relation() {
  _impl_._oneof_case_[0] = kVacuumRelation;
}
inline void Node::clear_vacuum_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kVacuumRelation) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kVacuumRelation) {
    clear_has_node();
    auto* temp = _impl_.node_.vacuum_relation_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.vacuum_relation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::VacuumRelation& Node::_internal_vacuum_relation() const {
  return node_case() == kVacuumRelation ? *_impl_.node_.vacuum_relation_ : reinterpret_cast<::pg_query::VacuumRelation&>(::pg_query::_VacuumRelation_default_instance_);
}
inline const ::pg_query::VacuumRelation& Node::vacuum_relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kVacuumRelation) {
    clear_has_node();
    auto* temp = _impl_.node_.vacuum_relation_;
    _impl_.node_.vacuum_relation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_vacuum_relation(::pg_query::VacuumRelation* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_vacuum_relation();
    _impl_.node_.vacuum_relation_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.vacuum_relation)
}
inline ::pg_query::VacuumRelation* Node::_internal_mutable_vacuum_relation() {
  if (node_case() != kVacuumRelation) {
    clear_node();
    set_has_vacuum_relation();
    _impl_.node_.vacuum_relation_ = CreateMaybeMessage<::pg_query::VacuumRelation>(GetArena());
  }
  return _impl_.node_.vacuum_relation_;
}
inline ::pg_query::VacuumRelation* Node::mutable_vacuum_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::VacuumRelation* _msg = _internal_mutable_vacuum_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.vacuum_relation)
  return _msg;
}

// .pg_query.ExplainStmt explain_stmt = 219 [json_name = "ExplainStmt"];
inline bool Node::has_explain_stmt() const {
  return node_case() == kExplainStmt;
}
inline bool Node::_internal_has_explain_stmt() const {
  return node_case() == kExplainStmt;
}
inline void Node::set_has_explain_stmt() {
  _impl_._oneof_case_[0] = kExplainStmt;
}
inline void Node::clear_explain_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kExplainStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kExplainStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.explain_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.explain_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ExplainStmt& Node::_internal_explain_stmt() const {
  return node_case() == kExplainStmt ? *_impl_.node_.explain_stmt_ : reinterpret_cast<::pg_query::ExplainStmt&>(::pg_query::_ExplainStmt_default_instance_);
}
inline const ::pg_query::ExplainStmt& Node::explain_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kExplainStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.explain_stmt_;
    _impl_.node_.explain_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_explain_stmt(::pg_query::ExplainStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_explain_stmt();
    _impl_.node_.explain_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.explain_stmt)
}
inline ::pg_query::ExplainStmt* Node::_internal_mutable_explain_stmt() {
  if (node_case() != kExplainStmt) {
    clear_node();
    set_has_explain_stmt();
    _impl_.node_.explain_stmt_ = CreateMaybeMessage<::pg_query::ExplainStmt>(GetArena());
  }
  return _impl_.node_.explain_stmt_;
}
inline ::pg_query::ExplainStmt* Node::mutable_explain_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ExplainStmt* _msg = _internal_mutable_explain_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.explain_stmt)
  return _msg;
}

// .pg_query.CreateTableAsStmt create_table_as_stmt = 220 [json_name = "CreateTableAsStmt"];
inline bool Node::has_create_table_as_stmt() const {
  return node_case() == kCreateTableAsStmt;
}
inline bool Node::_internal_has_create_table_as_stmt() const {
  return node_case() == kCreateTableAsStmt;
}
inline void Node::set_has_create_table_as_stmt() {
  _impl_._oneof_case_[0] = kCreateTableAsStmt;
}
inline void Node::clear_create_table_as_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateTableAsStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateTableAsStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_table_as_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_table_as_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateTableAsStmt& Node::_internal_create_table_as_stmt() const {
  return node_case() == kCreateTableAsStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateTableAsStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_table_as_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_table_as_stmt();
    _impl_.node_.create_table_as_stmt_ = value;
  }
  // @@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 (node_case() != kCreateTableAsStmt) {
    clear_node();
    set_has_create_table_as_stmt();
    _impl_.node_.create_table_as_stmt_ = CreateMaybeMessage<::pg_query::CreateTableAsStmt>(GetArena());
  }
  return _impl_.node_.create_table_as_stmt_;
}
inline ::pg_query::CreateTableAsStmt* Node::mutable_create_table_as_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateTableAsStmt* _msg = _internal_mutable_create_table_as_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_table_as_stmt)
  return _msg;
}

// .pg_query.RefreshMatViewStmt refresh_mat_view_stmt = 221 [json_name = "RefreshMatViewStmt"];
inline bool Node::has_refresh_mat_view_stmt() const {
  return node_case() == kRefreshMatViewStmt;
}
inline bool Node::_internal_has_refresh_mat_view_stmt() const {
  return node_case() == kRefreshMatViewStmt;
}
inline void Node::set_has_refresh_mat_view_stmt() {
  _impl_._oneof_case_[0] = kRefreshMatViewStmt;
}
inline void Node::clear_refresh_mat_view_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kRefreshMatViewStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kRefreshMatViewStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.refresh_mat_view_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.refresh_mat_view_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::RefreshMatViewStmt& Node::_internal_refresh_mat_view_stmt() const {
  return node_case() == kRefreshMatViewStmt ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kRefreshMatViewStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.refresh_mat_view_stmt_;
    _impl_.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* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_refresh_mat_view_stmt();
    _impl_.node_.refresh_mat_view_stmt_ = value;
  }
  // @@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 (node_case() != kRefreshMatViewStmt) {
    clear_node();
    set_has_refresh_mat_view_stmt();
    _impl_.node_.refresh_mat_view_stmt_ = CreateMaybeMessage<::pg_query::RefreshMatViewStmt>(GetArena());
  }
  return _impl_.node_.refresh_mat_view_stmt_;
}
inline ::pg_query::RefreshMatViewStmt* Node::mutable_refresh_mat_view_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RefreshMatViewStmt* _msg = _internal_mutable_refresh_mat_view_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.refresh_mat_view_stmt)
  return _msg;
}

// .pg_query.CheckPointStmt check_point_stmt = 222 [json_name = "CheckPointStmt"];
inline bool Node::has_check_point_stmt() const {
  return node_case() == kCheckPointStmt;
}
inline bool Node::_internal_has_check_point_stmt() const {
  return node_case() == kCheckPointStmt;
}
inline void Node::set_has_check_point_stmt() {
  _impl_._oneof_case_[0] = kCheckPointStmt;
}
inline void Node::clear_check_point_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCheckPointStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCheckPointStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.check_point_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.check_point_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CheckPointStmt& Node::_internal_check_point_stmt() const {
  return node_case() == kCheckPointStmt ? *_impl_.node_.check_point_stmt_ : reinterpret_cast<::pg_query::CheckPointStmt&>(::pg_query::_CheckPointStmt_default_instance_);
}
inline const ::pg_query::CheckPointStmt& Node::check_point_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCheckPointStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.check_point_stmt_;
    _impl_.node_.check_point_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_check_point_stmt(::pg_query::CheckPointStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_check_point_stmt();
    _impl_.node_.check_point_stmt_ = value;
  }
  // @@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 (node_case() != kCheckPointStmt) {
    clear_node();
    set_has_check_point_stmt();
    _impl_.node_.check_point_stmt_ = CreateMaybeMessage<::pg_query::CheckPointStmt>(GetArena());
  }
  return _impl_.node_.check_point_stmt_;
}
inline ::pg_query::CheckPointStmt* Node::mutable_check_point_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CheckPointStmt* _msg = _internal_mutable_check_point_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.check_point_stmt)
  return _msg;
}

// .pg_query.DiscardStmt discard_stmt = 223 [json_name = "DiscardStmt"];
inline bool Node::has_discard_stmt() const {
  return node_case() == kDiscardStmt;
}
inline bool Node::_internal_has_discard_stmt() const {
  return node_case() == kDiscardStmt;
}
inline void Node::set_has_discard_stmt() {
  _impl_._oneof_case_[0] = kDiscardStmt;
}
inline void Node::clear_discard_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDiscardStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDiscardStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.discard_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.discard_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DiscardStmt& Node::_internal_discard_stmt() const {
  return node_case() == kDiscardStmt ? *_impl_.node_.discard_stmt_ : reinterpret_cast<::pg_query::DiscardStmt&>(::pg_query::_DiscardStmt_default_instance_);
}
inline const ::pg_query::DiscardStmt& Node::discard_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDiscardStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.discard_stmt_;
    _impl_.node_.discard_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_discard_stmt(::pg_query::DiscardStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_discard_stmt();
    _impl_.node_.discard_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.discard_stmt)
}
inline ::pg_query::DiscardStmt* Node::_internal_mutable_discard_stmt() {
  if (node_case() != kDiscardStmt) {
    clear_node();
    set_has_discard_stmt();
    _impl_.node_.discard_stmt_ = CreateMaybeMessage<::pg_query::DiscardStmt>(GetArena());
  }
  return _impl_.node_.discard_stmt_;
}
inline ::pg_query::DiscardStmt* Node::mutable_discard_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DiscardStmt* _msg = _internal_mutable_discard_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.discard_stmt)
  return _msg;
}

// .pg_query.LockStmt lock_stmt = 224 [json_name = "LockStmt"];
inline bool Node::has_lock_stmt() const {
  return node_case() == kLockStmt;
}
inline bool Node::_internal_has_lock_stmt() const {
  return node_case() == kLockStmt;
}
inline void Node::set_has_lock_stmt() {
  _impl_._oneof_case_[0] = kLockStmt;
}
inline void Node::clear_lock_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kLockStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kLockStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.lock_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.lock_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::LockStmt& Node::_internal_lock_stmt() const {
  return node_case() == kLockStmt ? *_impl_.node_.lock_stmt_ : reinterpret_cast<::pg_query::LockStmt&>(::pg_query::_LockStmt_default_instance_);
}
inline const ::pg_query::LockStmt& Node::lock_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kLockStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.lock_stmt_;
    _impl_.node_.lock_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_lock_stmt(::pg_query::LockStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_lock_stmt();
    _impl_.node_.lock_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.lock_stmt)
}
inline ::pg_query::LockStmt* Node::_internal_mutable_lock_stmt() {
  if (node_case() != kLockStmt) {
    clear_node();
    set_has_lock_stmt();
    _impl_.node_.lock_stmt_ = CreateMaybeMessage<::pg_query::LockStmt>(GetArena());
  }
  return _impl_.node_.lock_stmt_;
}
inline ::pg_query::LockStmt* Node::mutable_lock_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::LockStmt* _msg = _internal_mutable_lock_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.lock_stmt)
  return _msg;
}

// .pg_query.ConstraintsSetStmt constraints_set_stmt = 225 [json_name = "ConstraintsSetStmt"];
inline bool Node::has_constraints_set_stmt() const {
  return node_case() == kConstraintsSetStmt;
}
inline bool Node::_internal_has_constraints_set_stmt() const {
  return node_case() == kConstraintsSetStmt;
}
inline void Node::set_has_constraints_set_stmt() {
  _impl_._oneof_case_[0] = kConstraintsSetStmt;
}
inline void Node::clear_constraints_set_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kConstraintsSetStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kConstraintsSetStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.constraints_set_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.constraints_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ConstraintsSetStmt& Node::_internal_constraints_set_stmt() const {
  return node_case() == kConstraintsSetStmt ? *_impl_.node_.constraints_set_stmt_ : reinterpret_cast<::pg_query::ConstraintsSetStmt&>(::pg_query::_ConstraintsSetStmt_default_instance_);
}
inline const ::pg_query::ConstraintsSetStmt& Node::constraints_set_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kConstraintsSetStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.constraints_set_stmt_;
    _impl_.node_.constraints_set_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_constraints_set_stmt(::pg_query::ConstraintsSetStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_constraints_set_stmt();
    _impl_.node_.constraints_set_stmt_ = value;
  }
  // @@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 (node_case() != kConstraintsSetStmt) {
    clear_node();
    set_has_constraints_set_stmt();
    _impl_.node_.constraints_set_stmt_ = CreateMaybeMessage<::pg_query::ConstraintsSetStmt>(GetArena());
  }
  return _impl_.node_.constraints_set_stmt_;
}
inline ::pg_query::ConstraintsSetStmt* Node::mutable_constraints_set_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ConstraintsSetStmt* _msg = _internal_mutable_constraints_set_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.constraints_set_stmt)
  return _msg;
}

// .pg_query.ReindexStmt reindex_stmt = 226 [json_name = "ReindexStmt"];
inline bool Node::has_reindex_stmt() const {
  return node_case() == kReindexStmt;
}
inline bool Node::_internal_has_reindex_stmt() const {
  return node_case() == kReindexStmt;
}
inline void Node::set_has_reindex_stmt() {
  _impl_._oneof_case_[0] = kReindexStmt;
}
inline void Node::clear_reindex_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kReindexStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kReindexStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.reindex_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.reindex_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ReindexStmt& Node::_internal_reindex_stmt() const {
  return node_case() == kReindexStmt ? *_impl_.node_.reindex_stmt_ : reinterpret_cast<::pg_query::ReindexStmt&>(::pg_query::_ReindexStmt_default_instance_);
}
inline const ::pg_query::ReindexStmt& Node::reindex_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kReindexStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.reindex_stmt_;
    _impl_.node_.reindex_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_reindex_stmt(::pg_query::ReindexStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_reindex_stmt();
    _impl_.node_.reindex_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.reindex_stmt)
}
inline ::pg_query::ReindexStmt* Node::_internal_mutable_reindex_stmt() {
  if (node_case() != kReindexStmt) {
    clear_node();
    set_has_reindex_stmt();
    _impl_.node_.reindex_stmt_ = CreateMaybeMessage<::pg_query::ReindexStmt>(GetArena());
  }
  return _impl_.node_.reindex_stmt_;
}
inline ::pg_query::ReindexStmt* Node::mutable_reindex_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ReindexStmt* _msg = _internal_mutable_reindex_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.reindex_stmt)
  return _msg;
}

// .pg_query.CreateConversionStmt create_conversion_stmt = 227 [json_name = "CreateConversionStmt"];
inline bool Node::has_create_conversion_stmt() const {
  return node_case() == kCreateConversionStmt;
}
inline bool Node::_internal_has_create_conversion_stmt() const {
  return node_case() == kCreateConversionStmt;
}
inline void Node::set_has_create_conversion_stmt() {
  _impl_._oneof_case_[0] = kCreateConversionStmt;
}
inline void Node::clear_create_conversion_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateConversionStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateConversionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_conversion_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_conversion_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateConversionStmt& Node::_internal_create_conversion_stmt() const {
  return node_case() == kCreateConversionStmt ? *_impl_.node_.create_conversion_stmt_ : reinterpret_cast<::pg_query::CreateConversionStmt&>(::pg_query::_CreateConversionStmt_default_instance_);
}
inline const ::pg_query::CreateConversionStmt& Node::create_conversion_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateConversionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_conversion_stmt_;
    _impl_.node_.create_conversion_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_conversion_stmt(::pg_query::CreateConversionStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_conversion_stmt();
    _impl_.node_.create_conversion_stmt_ = value;
  }
  // @@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 (node_case() != kCreateConversionStmt) {
    clear_node();
    set_has_create_conversion_stmt();
    _impl_.node_.create_conversion_stmt_ = CreateMaybeMessage<::pg_query::CreateConversionStmt>(GetArena());
  }
  return _impl_.node_.create_conversion_stmt_;
}
inline ::pg_query::CreateConversionStmt* Node::mutable_create_conversion_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateConversionStmt* _msg = _internal_mutable_create_conversion_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_conversion_stmt)
  return _msg;
}

// .pg_query.CreateCastStmt create_cast_stmt = 228 [json_name = "CreateCastStmt"];
inline bool Node::has_create_cast_stmt() const {
  return node_case() == kCreateCastStmt;
}
inline bool Node::_internal_has_create_cast_stmt() const {
  return node_case() == kCreateCastStmt;
}
inline void Node::set_has_create_cast_stmt() {
  _impl_._oneof_case_[0] = kCreateCastStmt;
}
inline void Node::clear_create_cast_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateCastStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateCastStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_cast_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_cast_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateCastStmt& Node::_internal_create_cast_stmt() const {
  return node_case() == kCreateCastStmt ? *_impl_.node_.create_cast_stmt_ : reinterpret_cast<::pg_query::CreateCastStmt&>(::pg_query::_CreateCastStmt_default_instance_);
}
inline const ::pg_query::CreateCastStmt& Node::create_cast_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateCastStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_cast_stmt_;
    _impl_.node_.create_cast_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_cast_stmt(::pg_query::CreateCastStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_cast_stmt();
    _impl_.node_.create_cast_stmt_ = value;
  }
  // @@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 (node_case() != kCreateCastStmt) {
    clear_node();
    set_has_create_cast_stmt();
    _impl_.node_.create_cast_stmt_ = CreateMaybeMessage<::pg_query::CreateCastStmt>(GetArena());
  }
  return _impl_.node_.create_cast_stmt_;
}
inline ::pg_query::CreateCastStmt* Node::mutable_create_cast_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateCastStmt* _msg = _internal_mutable_create_cast_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_cast_stmt)
  return _msg;
}

// .pg_query.CreateTransformStmt create_transform_stmt = 229 [json_name = "CreateTransformStmt"];
inline bool Node::has_create_transform_stmt() const {
  return node_case() == kCreateTransformStmt;
}
inline bool Node::_internal_has_create_transform_stmt() const {
  return node_case() == kCreateTransformStmt;
}
inline void Node::set_has_create_transform_stmt() {
  _impl_._oneof_case_[0] = kCreateTransformStmt;
}
inline void Node::clear_create_transform_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateTransformStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateTransformStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_transform_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_transform_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateTransformStmt& Node::_internal_create_transform_stmt() const {
  return node_case() == kCreateTransformStmt ? *_impl_.node_.create_transform_stmt_ : reinterpret_cast<::pg_query::CreateTransformStmt&>(::pg_query::_CreateTransformStmt_default_instance_);
}
inline const ::pg_query::CreateTransformStmt& Node::create_transform_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateTransformStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_transform_stmt_;
    _impl_.node_.create_transform_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_transform_stmt(::pg_query::CreateTransformStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_transform_stmt();
    _impl_.node_.create_transform_stmt_ = value;
  }
  // @@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 (node_case() != kCreateTransformStmt) {
    clear_node();
    set_has_create_transform_stmt();
    _impl_.node_.create_transform_stmt_ = CreateMaybeMessage<::pg_query::CreateTransformStmt>(GetArena());
  }
  return _impl_.node_.create_transform_stmt_;
}
inline ::pg_query::CreateTransformStmt* Node::mutable_create_transform_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateTransformStmt* _msg = _internal_mutable_create_transform_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_transform_stmt)
  return _msg;
}

// .pg_query.PrepareStmt prepare_stmt = 230 [json_name = "PrepareStmt"];
inline bool Node::has_prepare_stmt() const {
  return node_case() == kPrepareStmt;
}
inline bool Node::_internal_has_prepare_stmt() const {
  return node_case() == kPrepareStmt;
}
inline void Node::set_has_prepare_stmt() {
  _impl_._oneof_case_[0] = kPrepareStmt;
}
inline void Node::clear_prepare_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kPrepareStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kPrepareStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.prepare_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.prepare_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PrepareStmt& Node::_internal_prepare_stmt() const {
  return node_case() == kPrepareStmt ? *_impl_.node_.prepare_stmt_ : reinterpret_cast<::pg_query::PrepareStmt&>(::pg_query::_PrepareStmt_default_instance_);
}
inline const ::pg_query::PrepareStmt& Node::prepare_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kPrepareStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.prepare_stmt_;
    _impl_.node_.prepare_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_prepare_stmt(::pg_query::PrepareStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_prepare_stmt();
    _impl_.node_.prepare_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.prepare_stmt)
}
inline ::pg_query::PrepareStmt* Node::_internal_mutable_prepare_stmt() {
  if (node_case() != kPrepareStmt) {
    clear_node();
    set_has_prepare_stmt();
    _impl_.node_.prepare_stmt_ = CreateMaybeMessage<::pg_query::PrepareStmt>(GetArena());
  }
  return _impl_.node_.prepare_stmt_;
}
inline ::pg_query::PrepareStmt* Node::mutable_prepare_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PrepareStmt* _msg = _internal_mutable_prepare_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.prepare_stmt)
  return _msg;
}

// .pg_query.ExecuteStmt execute_stmt = 231 [json_name = "ExecuteStmt"];
inline bool Node::has_execute_stmt() const {
  return node_case() == kExecuteStmt;
}
inline bool Node::_internal_has_execute_stmt() const {
  return node_case() == kExecuteStmt;
}
inline void Node::set_has_execute_stmt() {
  _impl_._oneof_case_[0] = kExecuteStmt;
}
inline void Node::clear_execute_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kExecuteStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kExecuteStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.execute_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.execute_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ExecuteStmt& Node::_internal_execute_stmt() const {
  return node_case() == kExecuteStmt ? *_impl_.node_.execute_stmt_ : reinterpret_cast<::pg_query::ExecuteStmt&>(::pg_query::_ExecuteStmt_default_instance_);
}
inline const ::pg_query::ExecuteStmt& Node::execute_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kExecuteStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.execute_stmt_;
    _impl_.node_.execute_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_execute_stmt(::pg_query::ExecuteStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_execute_stmt();
    _impl_.node_.execute_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.execute_stmt)
}
inline ::pg_query::ExecuteStmt* Node::_internal_mutable_execute_stmt() {
  if (node_case() != kExecuteStmt) {
    clear_node();
    set_has_execute_stmt();
    _impl_.node_.execute_stmt_ = CreateMaybeMessage<::pg_query::ExecuteStmt>(GetArena());
  }
  return _impl_.node_.execute_stmt_;
}
inline ::pg_query::ExecuteStmt* Node::mutable_execute_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ExecuteStmt* _msg = _internal_mutable_execute_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.execute_stmt)
  return _msg;
}

// .pg_query.DeallocateStmt deallocate_stmt = 232 [json_name = "DeallocateStmt"];
inline bool Node::has_deallocate_stmt() const {
  return node_case() == kDeallocateStmt;
}
inline bool Node::_internal_has_deallocate_stmt() const {
  return node_case() == kDeallocateStmt;
}
inline void Node::set_has_deallocate_stmt() {
  _impl_._oneof_case_[0] = kDeallocateStmt;
}
inline void Node::clear_deallocate_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDeallocateStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDeallocateStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.deallocate_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.deallocate_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DeallocateStmt& Node::_internal_deallocate_stmt() const {
  return node_case() == kDeallocateStmt ? *_impl_.node_.deallocate_stmt_ : reinterpret_cast<::pg_query::DeallocateStmt&>(::pg_query::_DeallocateStmt_default_instance_);
}
inline const ::pg_query::DeallocateStmt& Node::deallocate_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDeallocateStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.deallocate_stmt_;
    _impl_.node_.deallocate_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_deallocate_stmt(::pg_query::DeallocateStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_deallocate_stmt();
    _impl_.node_.deallocate_stmt_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.deallocate_stmt)
}
inline ::pg_query::DeallocateStmt* Node::_internal_mutable_deallocate_stmt() {
  if (node_case() != kDeallocateStmt) {
    clear_node();
    set_has_deallocate_stmt();
    _impl_.node_.deallocate_stmt_ = CreateMaybeMessage<::pg_query::DeallocateStmt>(GetArena());
  }
  return _impl_.node_.deallocate_stmt_;
}
inline ::pg_query::DeallocateStmt* Node::mutable_deallocate_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DeallocateStmt* _msg = _internal_mutable_deallocate_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.deallocate_stmt)
  return _msg;
}

// .pg_query.DropOwnedStmt drop_owned_stmt = 233 [json_name = "DropOwnedStmt"];
inline bool Node::has_drop_owned_stmt() const {
  return node_case() == kDropOwnedStmt;
}
inline bool Node::_internal_has_drop_owned_stmt() const {
  return node_case() == kDropOwnedStmt;
}
inline void Node::set_has_drop_owned_stmt() {
  _impl_._oneof_case_[0] = kDropOwnedStmt;
}
inline void Node::clear_drop_owned_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDropOwnedStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDropOwnedStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.drop_owned_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.drop_owned_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropOwnedStmt& Node::_internal_drop_owned_stmt() const {
  return node_case() == kDropOwnedStmt ? *_impl_.node_.drop_owned_stmt_ : reinterpret_cast<::pg_query::DropOwnedStmt&>(::pg_query::_DropOwnedStmt_default_instance_);
}
inline const ::pg_query::DropOwnedStmt& Node::drop_owned_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDropOwnedStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.drop_owned_stmt_;
    _impl_.node_.drop_owned_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_drop_owned_stmt(::pg_query::DropOwnedStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_drop_owned_stmt();
    _impl_.node_.drop_owned_stmt_ = value;
  }
  // @@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 (node_case() != kDropOwnedStmt) {
    clear_node();
    set_has_drop_owned_stmt();
    _impl_.node_.drop_owned_stmt_ = CreateMaybeMessage<::pg_query::DropOwnedStmt>(GetArena());
  }
  return _impl_.node_.drop_owned_stmt_;
}
inline ::pg_query::DropOwnedStmt* Node::mutable_drop_owned_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DropOwnedStmt* _msg = _internal_mutable_drop_owned_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_owned_stmt)
  return _msg;
}

// .pg_query.ReassignOwnedStmt reassign_owned_stmt = 234 [json_name = "ReassignOwnedStmt"];
inline bool Node::has_reassign_owned_stmt() const {
  return node_case() == kReassignOwnedStmt;
}
inline bool Node::_internal_has_reassign_owned_stmt() const {
  return node_case() == kReassignOwnedStmt;
}
inline void Node::set_has_reassign_owned_stmt() {
  _impl_._oneof_case_[0] = kReassignOwnedStmt;
}
inline void Node::clear_reassign_owned_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kReassignOwnedStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kReassignOwnedStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.reassign_owned_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.reassign_owned_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::ReassignOwnedStmt& Node::_internal_reassign_owned_stmt() const {
  return node_case() == kReassignOwnedStmt ? *_impl_.node_.reassign_owned_stmt_ : reinterpret_cast<::pg_query::ReassignOwnedStmt&>(::pg_query::_ReassignOwnedStmt_default_instance_);
}
inline const ::pg_query::ReassignOwnedStmt& Node::reassign_owned_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kReassignOwnedStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.reassign_owned_stmt_;
    _impl_.node_.reassign_owned_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_reassign_owned_stmt(::pg_query::ReassignOwnedStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_reassign_owned_stmt();
    _impl_.node_.reassign_owned_stmt_ = value;
  }
  // @@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 (node_case() != kReassignOwnedStmt) {
    clear_node();
    set_has_reassign_owned_stmt();
    _impl_.node_.reassign_owned_stmt_ = CreateMaybeMessage<::pg_query::ReassignOwnedStmt>(GetArena());
  }
  return _impl_.node_.reassign_owned_stmt_;
}
inline ::pg_query::ReassignOwnedStmt* Node::mutable_reassign_owned_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ReassignOwnedStmt* _msg = _internal_mutable_reassign_owned_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.reassign_owned_stmt)
  return _msg;
}

// .pg_query.AlterTSDictionaryStmt alter_tsdictionary_stmt = 235 [json_name = "AlterTSDictionaryStmt"];
inline bool Node::has_alter_tsdictionary_stmt() const {
  return node_case() == kAlterTsdictionaryStmt;
}
inline bool Node::_internal_has_alter_tsdictionary_stmt() const {
  return node_case() == kAlterTsdictionaryStmt;
}
inline void Node::set_has_alter_tsdictionary_stmt() {
  _impl_._oneof_case_[0] = kAlterTsdictionaryStmt;
}
inline void Node::clear_alter_tsdictionary_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterTsdictionaryStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterTsdictionaryStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_tsdictionary_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_tsdictionary_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterTSDictionaryStmt& Node::_internal_alter_tsdictionary_stmt() const {
  return node_case() == kAlterTsdictionaryStmt ? *_impl_.node_.alter_tsdictionary_stmt_ : reinterpret_cast<::pg_query::AlterTSDictionaryStmt&>(::pg_query::_AlterTSDictionaryStmt_default_instance_);
}
inline const ::pg_query::AlterTSDictionaryStmt& Node::alter_tsdictionary_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterTsdictionaryStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_tsdictionary_stmt_;
    _impl_.node_.alter_tsdictionary_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_tsdictionary_stmt(::pg_query::AlterTSDictionaryStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_tsdictionary_stmt();
    _impl_.node_.alter_tsdictionary_stmt_ = value;
  }
  // @@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 (node_case() != kAlterTsdictionaryStmt) {
    clear_node();
    set_has_alter_tsdictionary_stmt();
    _impl_.node_.alter_tsdictionary_stmt_ = CreateMaybeMessage<::pg_query::AlterTSDictionaryStmt>(GetArena());
  }
  return _impl_.node_.alter_tsdictionary_stmt_;
}
inline ::pg_query::AlterTSDictionaryStmt* Node::mutable_alter_tsdictionary_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterTSDictionaryStmt* _msg = _internal_mutable_alter_tsdictionary_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_tsdictionary_stmt)
  return _msg;
}

// .pg_query.AlterTSConfigurationStmt alter_tsconfiguration_stmt = 236 [json_name = "AlterTSConfigurationStmt"];
inline bool Node::has_alter_tsconfiguration_stmt() const {
  return node_case() == kAlterTsconfigurationStmt;
}
inline bool Node::_internal_has_alter_tsconfiguration_stmt() const {
  return node_case() == kAlterTsconfigurationStmt;
}
inline void Node::set_has_alter_tsconfiguration_stmt() {
  _impl_._oneof_case_[0] = kAlterTsconfigurationStmt;
}
inline void Node::clear_alter_tsconfiguration_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterTsconfigurationStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterTsconfigurationStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_tsconfiguration_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_tsconfiguration_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterTSConfigurationStmt& Node::_internal_alter_tsconfiguration_stmt() const {
  return node_case() == kAlterTsconfigurationStmt ? *_impl_.node_.alter_tsconfiguration_stmt_ : reinterpret_cast<::pg_query::AlterTSConfigurationStmt&>(::pg_query::_AlterTSConfigurationStmt_default_instance_);
}
inline const ::pg_query::AlterTSConfigurationStmt& Node::alter_tsconfiguration_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterTsconfigurationStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_tsconfiguration_stmt_;
    _impl_.node_.alter_tsconfiguration_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_tsconfiguration_stmt(::pg_query::AlterTSConfigurationStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_tsconfiguration_stmt();
    _impl_.node_.alter_tsconfiguration_stmt_ = value;
  }
  // @@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 (node_case() != kAlterTsconfigurationStmt) {
    clear_node();
    set_has_alter_tsconfiguration_stmt();
    _impl_.node_.alter_tsconfiguration_stmt_ = CreateMaybeMessage<::pg_query::AlterTSConfigurationStmt>(GetArena());
  }
  return _impl_.node_.alter_tsconfiguration_stmt_;
}
inline ::pg_query::AlterTSConfigurationStmt* Node::mutable_alter_tsconfiguration_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterTSConfigurationStmt* _msg = _internal_mutable_alter_tsconfiguration_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_tsconfiguration_stmt)
  return _msg;
}

// .pg_query.PublicationTable publication_table = 237 [json_name = "PublicationTable"];
inline bool Node::has_publication_table() const {
  return node_case() == kPublicationTable;
}
inline bool Node::_internal_has_publication_table() const {
  return node_case() == kPublicationTable;
}
inline void Node::set_has_publication_table() {
  _impl_._oneof_case_[0] = kPublicationTable;
}
inline void Node::clear_publication_table() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kPublicationTable) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.publication_table_;
    }
    clear_has_node();
  }
}
inline ::pg_query::PublicationTable* Node::release_publication_table() {
  // @@protoc_insertion_point(field_release:pg_query.Node.publication_table)
  if (node_case() == kPublicationTable) {
    clear_has_node();
    auto* temp = _impl_.node_.publication_table_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.publication_table_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PublicationTable& Node::_internal_publication_table() const {
  return node_case() == kPublicationTable ? *_impl_.node_.publication_table_ : reinterpret_cast<::pg_query::PublicationTable&>(::pg_query::_PublicationTable_default_instance_);
}
inline const ::pg_query::PublicationTable& Node::publication_table() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.publication_table)
  return _internal_publication_table();
}
inline ::pg_query::PublicationTable* Node::unsafe_arena_release_publication_table() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.publication_table)
  if (node_case() == kPublicationTable) {
    clear_has_node();
    auto* temp = _impl_.node_.publication_table_;
    _impl_.node_.publication_table_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_publication_table(::pg_query::PublicationTable* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_publication_table();
    _impl_.node_.publication_table_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.publication_table)
}
inline ::pg_query::PublicationTable* Node::_internal_mutable_publication_table() {
  if (node_case() != kPublicationTable) {
    clear_node();
    set_has_publication_table();
    _impl_.node_.publication_table_ = CreateMaybeMessage<::pg_query::PublicationTable>(GetArena());
  }
  return _impl_.node_.publication_table_;
}
inline ::pg_query::PublicationTable* Node::mutable_publication_table() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PublicationTable* _msg = _internal_mutable_publication_table();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.publication_table)
  return _msg;
}

// .pg_query.PublicationObjSpec publication_obj_spec = 238 [json_name = "PublicationObjSpec"];
inline bool Node::has_publication_obj_spec() const {
  return node_case() == kPublicationObjSpec;
}
inline bool Node::_internal_has_publication_obj_spec() const {
  return node_case() == kPublicationObjSpec;
}
inline void Node::set_has_publication_obj_spec() {
  _impl_._oneof_case_[0] = kPublicationObjSpec;
}
inline void Node::clear_publication_obj_spec() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kPublicationObjSpec) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.publication_obj_spec_;
    }
    clear_has_node();
  }
}
inline ::pg_query::PublicationObjSpec* Node::release_publication_obj_spec() {
  // @@protoc_insertion_point(field_release:pg_query.Node.publication_obj_spec)
  if (node_case() == kPublicationObjSpec) {
    clear_has_node();
    auto* temp = _impl_.node_.publication_obj_spec_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.publication_obj_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::PublicationObjSpec& Node::_internal_publication_obj_spec() const {
  return node_case() == kPublicationObjSpec ? *_impl_.node_.publication_obj_spec_ : reinterpret_cast<::pg_query::PublicationObjSpec&>(::pg_query::_PublicationObjSpec_default_instance_);
}
inline const ::pg_query::PublicationObjSpec& Node::publication_obj_spec() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.publication_obj_spec)
  return _internal_publication_obj_spec();
}
inline ::pg_query::PublicationObjSpec* Node::unsafe_arena_release_publication_obj_spec() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.publication_obj_spec)
  if (node_case() == kPublicationObjSpec) {
    clear_has_node();
    auto* temp = _impl_.node_.publication_obj_spec_;
    _impl_.node_.publication_obj_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_publication_obj_spec(::pg_query::PublicationObjSpec* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_publication_obj_spec();
    _impl_.node_.publication_obj_spec_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.publication_obj_spec)
}
inline ::pg_query::PublicationObjSpec* Node::_internal_mutable_publication_obj_spec() {
  if (node_case() != kPublicationObjSpec) {
    clear_node();
    set_has_publication_obj_spec();
    _impl_.node_.publication_obj_spec_ = CreateMaybeMessage<::pg_query::PublicationObjSpec>(GetArena());
  }
  return _impl_.node_.publication_obj_spec_;
}
inline ::pg_query::PublicationObjSpec* Node::mutable_publication_obj_spec() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PublicationObjSpec* _msg = _internal_mutable_publication_obj_spec();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.publication_obj_spec)
  return _msg;
}

// .pg_query.CreatePublicationStmt create_publication_stmt = 239 [json_name = "CreatePublicationStmt"];
inline bool Node::has_create_publication_stmt() const {
  return node_case() == kCreatePublicationStmt;
}
inline bool Node::_internal_has_create_publication_stmt() const {
  return node_case() == kCreatePublicationStmt;
}
inline void Node::set_has_create_publication_stmt() {
  _impl_._oneof_case_[0] = kCreatePublicationStmt;
}
inline void Node::clear_create_publication_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreatePublicationStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreatePublicationStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_publication_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_publication_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreatePublicationStmt& Node::_internal_create_publication_stmt() const {
  return node_case() == kCreatePublicationStmt ? *_impl_.node_.create_publication_stmt_ : reinterpret_cast<::pg_query::CreatePublicationStmt&>(::pg_query::_CreatePublicationStmt_default_instance_);
}
inline const ::pg_query::CreatePublicationStmt& Node::create_publication_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreatePublicationStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_publication_stmt_;
    _impl_.node_.create_publication_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_publication_stmt(::pg_query::CreatePublicationStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_publication_stmt();
    _impl_.node_.create_publication_stmt_ = value;
  }
  // @@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 (node_case() != kCreatePublicationStmt) {
    clear_node();
    set_has_create_publication_stmt();
    _impl_.node_.create_publication_stmt_ = CreateMaybeMessage<::pg_query::CreatePublicationStmt>(GetArena());
  }
  return _impl_.node_.create_publication_stmt_;
}
inline ::pg_query::CreatePublicationStmt* Node::mutable_create_publication_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreatePublicationStmt* _msg = _internal_mutable_create_publication_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_publication_stmt)
  return _msg;
}

// .pg_query.AlterPublicationStmt alter_publication_stmt = 240 [json_name = "AlterPublicationStmt"];
inline bool Node::has_alter_publication_stmt() const {
  return node_case() == kAlterPublicationStmt;
}
inline bool Node::_internal_has_alter_publication_stmt() const {
  return node_case() == kAlterPublicationStmt;
}
inline void Node::set_has_alter_publication_stmt() {
  _impl_._oneof_case_[0] = kAlterPublicationStmt;
}
inline void Node::clear_alter_publication_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterPublicationStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterPublicationStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_publication_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_publication_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterPublicationStmt& Node::_internal_alter_publication_stmt() const {
  return node_case() == kAlterPublicationStmt ? *_impl_.node_.alter_publication_stmt_ : reinterpret_cast<::pg_query::AlterPublicationStmt&>(::pg_query::_AlterPublicationStmt_default_instance_);
}
inline const ::pg_query::AlterPublicationStmt& Node::alter_publication_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterPublicationStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_publication_stmt_;
    _impl_.node_.alter_publication_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_publication_stmt(::pg_query::AlterPublicationStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_publication_stmt();
    _impl_.node_.alter_publication_stmt_ = value;
  }
  // @@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 (node_case() != kAlterPublicationStmt) {
    clear_node();
    set_has_alter_publication_stmt();
    _impl_.node_.alter_publication_stmt_ = CreateMaybeMessage<::pg_query::AlterPublicationStmt>(GetArena());
  }
  return _impl_.node_.alter_publication_stmt_;
}
inline ::pg_query::AlterPublicationStmt* Node::mutable_alter_publication_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterPublicationStmt* _msg = _internal_mutable_alter_publication_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_publication_stmt)
  return _msg;
}

// .pg_query.CreateSubscriptionStmt create_subscription_stmt = 241 [json_name = "CreateSubscriptionStmt"];
inline bool Node::has_create_subscription_stmt() const {
  return node_case() == kCreateSubscriptionStmt;
}
inline bool Node::_internal_has_create_subscription_stmt() const {
  return node_case() == kCreateSubscriptionStmt;
}
inline void Node::set_has_create_subscription_stmt() {
  _impl_._oneof_case_[0] = kCreateSubscriptionStmt;
}
inline void Node::clear_create_subscription_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kCreateSubscriptionStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kCreateSubscriptionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_subscription_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.create_subscription_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::CreateSubscriptionStmt& Node::_internal_create_subscription_stmt() const {
  return node_case() == kCreateSubscriptionStmt ? *_impl_.node_.create_subscription_stmt_ : reinterpret_cast<::pg_query::CreateSubscriptionStmt&>(::pg_query::_CreateSubscriptionStmt_default_instance_);
}
inline const ::pg_query::CreateSubscriptionStmt& Node::create_subscription_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kCreateSubscriptionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.create_subscription_stmt_;
    _impl_.node_.create_subscription_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_create_subscription_stmt(::pg_query::CreateSubscriptionStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_create_subscription_stmt();
    _impl_.node_.create_subscription_stmt_ = value;
  }
  // @@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 (node_case() != kCreateSubscriptionStmt) {
    clear_node();
    set_has_create_subscription_stmt();
    _impl_.node_.create_subscription_stmt_ = CreateMaybeMessage<::pg_query::CreateSubscriptionStmt>(GetArena());
  }
  return _impl_.node_.create_subscription_stmt_;
}
inline ::pg_query::CreateSubscriptionStmt* Node::mutable_create_subscription_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateSubscriptionStmt* _msg = _internal_mutable_create_subscription_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.create_subscription_stmt)
  return _msg;
}

// .pg_query.AlterSubscriptionStmt alter_subscription_stmt = 242 [json_name = "AlterSubscriptionStmt"];
inline bool Node::has_alter_subscription_stmt() const {
  return node_case() == kAlterSubscriptionStmt;
}
inline bool Node::_internal_has_alter_subscription_stmt() const {
  return node_case() == kAlterSubscriptionStmt;
}
inline void Node::set_has_alter_subscription_stmt() {
  _impl_._oneof_case_[0] = kAlterSubscriptionStmt;
}
inline void Node::clear_alter_subscription_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAlterSubscriptionStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAlterSubscriptionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_subscription_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.alter_subscription_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::AlterSubscriptionStmt& Node::_internal_alter_subscription_stmt() const {
  return node_case() == kAlterSubscriptionStmt ? *_impl_.node_.alter_subscription_stmt_ : reinterpret_cast<::pg_query::AlterSubscriptionStmt&>(::pg_query::_AlterSubscriptionStmt_default_instance_);
}
inline const ::pg_query::AlterSubscriptionStmt& Node::alter_subscription_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAlterSubscriptionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.alter_subscription_stmt_;
    _impl_.node_.alter_subscription_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_alter_subscription_stmt(::pg_query::AlterSubscriptionStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_alter_subscription_stmt();
    _impl_.node_.alter_subscription_stmt_ = value;
  }
  // @@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 (node_case() != kAlterSubscriptionStmt) {
    clear_node();
    set_has_alter_subscription_stmt();
    _impl_.node_.alter_subscription_stmt_ = CreateMaybeMessage<::pg_query::AlterSubscriptionStmt>(GetArena());
  }
  return _impl_.node_.alter_subscription_stmt_;
}
inline ::pg_query::AlterSubscriptionStmt* Node::mutable_alter_subscription_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::AlterSubscriptionStmt* _msg = _internal_mutable_alter_subscription_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_subscription_stmt)
  return _msg;
}

// .pg_query.DropSubscriptionStmt drop_subscription_stmt = 243 [json_name = "DropSubscriptionStmt"];
inline bool Node::has_drop_subscription_stmt() const {
  return node_case() == kDropSubscriptionStmt;
}
inline bool Node::_internal_has_drop_subscription_stmt() const {
  return node_case() == kDropSubscriptionStmt;
}
inline void Node::set_has_drop_subscription_stmt() {
  _impl_._oneof_case_[0] = kDropSubscriptionStmt;
}
inline void Node::clear_drop_subscription_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kDropSubscriptionStmt) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kDropSubscriptionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.drop_subscription_stmt_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.drop_subscription_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::DropSubscriptionStmt& Node::_internal_drop_subscription_stmt() const {
  return node_case() == kDropSubscriptionStmt ? *_impl_.node_.drop_subscription_stmt_ : reinterpret_cast<::pg_query::DropSubscriptionStmt&>(::pg_query::_DropSubscriptionStmt_default_instance_);
}
inline const ::pg_query::DropSubscriptionStmt& Node::drop_subscription_stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kDropSubscriptionStmt) {
    clear_has_node();
    auto* temp = _impl_.node_.drop_subscription_stmt_;
    _impl_.node_.drop_subscription_stmt_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_drop_subscription_stmt(::pg_query::DropSubscriptionStmt* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_drop_subscription_stmt();
    _impl_.node_.drop_subscription_stmt_ = value;
  }
  // @@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 (node_case() != kDropSubscriptionStmt) {
    clear_node();
    set_has_drop_subscription_stmt();
    _impl_.node_.drop_subscription_stmt_ = CreateMaybeMessage<::pg_query::DropSubscriptionStmt>(GetArena());
  }
  return _impl_.node_.drop_subscription_stmt_;
}
inline ::pg_query::DropSubscriptionStmt* Node::mutable_drop_subscription_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::DropSubscriptionStmt* _msg = _internal_mutable_drop_subscription_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_subscription_stmt)
  return _msg;
}

// .pg_query.Integer integer = 244 [json_name = "Integer"];
inline bool Node::has_integer() const {
  return node_case() == kInteger;
}
inline bool Node::_internal_has_integer() const {
  return node_case() == kInteger;
}
inline void Node::set_has_integer() {
  _impl_._oneof_case_[0] = kInteger;
}
inline void Node::clear_integer() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kInteger) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.integer_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Integer* Node::release_integer() {
  // @@protoc_insertion_point(field_release:pg_query.Node.integer)
  if (node_case() == kInteger) {
    clear_has_node();
    auto* temp = _impl_.node_.integer_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.integer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Integer& Node::_internal_integer() const {
  return node_case() == kInteger ? *_impl_.node_.integer_ : reinterpret_cast<::pg_query::Integer&>(::pg_query::_Integer_default_instance_);
}
inline const ::pg_query::Integer& Node::integer() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kInteger) {
    clear_has_node();
    auto* temp = _impl_.node_.integer_;
    _impl_.node_.integer_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_integer(::pg_query::Integer* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_integer();
    _impl_.node_.integer_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.integer)
}
inline ::pg_query::Integer* Node::_internal_mutable_integer() {
  if (node_case() != kInteger) {
    clear_node();
    set_has_integer();
    _impl_.node_.integer_ = CreateMaybeMessage<::pg_query::Integer>(GetArena());
  }
  return _impl_.node_.integer_;
}
inline ::pg_query::Integer* Node::mutable_integer() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Integer* _msg = _internal_mutable_integer();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.integer)
  return _msg;
}

// .pg_query.Float float = 245 [json_name = "Float"];
inline bool Node::has_float_() const {
  return node_case() == kFloat;
}
inline bool Node::_internal_has_float_() const {
  return node_case() == kFloat;
}
inline void Node::set_has_float_() {
  _impl_._oneof_case_[0] = kFloat;
}
inline void Node::clear_float_() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kFloat) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.float__;
    }
    clear_has_node();
  }
}
inline ::pg_query::Float* Node::release_float_() {
  // @@protoc_insertion_point(field_release:pg_query.Node.float)
  if (node_case() == kFloat) {
    clear_has_node();
    auto* temp = _impl_.node_.float__;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.float__ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Float& Node::_internal_float_() const {
  return node_case() == kFloat ? *_impl_.node_.float__ : reinterpret_cast<::pg_query::Float&>(::pg_query::_Float_default_instance_);
}
inline const ::pg_query::Float& Node::float_() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kFloat) {
    clear_has_node();
    auto* temp = _impl_.node_.float__;
    _impl_.node_.float__ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_float_(::pg_query::Float* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_float_();
    _impl_.node_.float__ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.float)
}
inline ::pg_query::Float* Node::_internal_mutable_float_() {
  if (node_case() != kFloat) {
    clear_node();
    set_has_float_();
    _impl_.node_.float__ = CreateMaybeMessage<::pg_query::Float>(GetArena());
  }
  return _impl_.node_.float__;
}
inline ::pg_query::Float* Node::mutable_float_() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Float* _msg = _internal_mutable_float_();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.float)
  return _msg;
}

// .pg_query.Boolean boolean = 246 [json_name = "Boolean"];
inline bool Node::has_boolean() const {
  return node_case() == kBoolean;
}
inline bool Node::_internal_has_boolean() const {
  return node_case() == kBoolean;
}
inline void Node::set_has_boolean() {
  _impl_._oneof_case_[0] = kBoolean;
}
inline void Node::clear_boolean() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kBoolean) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.boolean_;
    }
    clear_has_node();
  }
}
inline ::pg_query::Boolean* Node::release_boolean() {
  // @@protoc_insertion_point(field_release:pg_query.Node.boolean)
  if (node_case() == kBoolean) {
    clear_has_node();
    auto* temp = _impl_.node_.boolean_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.boolean_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Boolean& Node::_internal_boolean() const {
  return node_case() == kBoolean ? *_impl_.node_.boolean_ : reinterpret_cast<::pg_query::Boolean&>(::pg_query::_Boolean_default_instance_);
}
inline const ::pg_query::Boolean& Node::boolean() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Node.boolean)
  return _internal_boolean();
}
inline ::pg_query::Boolean* Node::unsafe_arena_release_boolean() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.boolean)
  if (node_case() == kBoolean) {
    clear_has_node();
    auto* temp = _impl_.node_.boolean_;
    _impl_.node_.boolean_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_boolean(::pg_query::Boolean* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_boolean();
    _impl_.node_.boolean_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.boolean)
}
inline ::pg_query::Boolean* Node::_internal_mutable_boolean() {
  if (node_case() != kBoolean) {
    clear_node();
    set_has_boolean();
    _impl_.node_.boolean_ = CreateMaybeMessage<::pg_query::Boolean>(GetArena());
  }
  return _impl_.node_.boolean_;
}
inline ::pg_query::Boolean* Node::mutable_boolean() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Boolean* _msg = _internal_mutable_boolean();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.boolean)
  return _msg;
}

// .pg_query.String string = 247 [json_name = "String"];
inline bool Node::has_string() const {
  return node_case() == kString;
}
inline bool Node::_internal_has_string() const {
  return node_case() == kString;
}
inline void Node::set_has_string() {
  _impl_._oneof_case_[0] = kString;
}
inline void Node::clear_string() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kString) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.string_;
    }
    clear_has_node();
  }
}
inline ::pg_query::String* Node::release_string() {
  // @@protoc_insertion_point(field_release:pg_query.Node.string)
  if (node_case() == kString) {
    clear_has_node();
    auto* temp = _impl_.node_.string_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.string_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::String& Node::_internal_string() const {
  return node_case() == kString ? *_impl_.node_.string_ : reinterpret_cast<::pg_query::String&>(::pg_query::_String_default_instance_);
}
inline const ::pg_query::String& Node::string() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kString) {
    clear_has_node();
    auto* temp = _impl_.node_.string_;
    _impl_.node_.string_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_string(::pg_query::String* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_string();
    _impl_.node_.string_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.string)
}
inline ::pg_query::String* Node::_internal_mutable_string() {
  if (node_case() != kString) {
    clear_node();
    set_has_string();
    _impl_.node_.string_ = CreateMaybeMessage<::pg_query::String>(GetArena());
  }
  return _impl_.node_.string_;
}
inline ::pg_query::String* Node::mutable_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::String* _msg = _internal_mutable_string();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.string)
  return _msg;
}

// .pg_query.BitString bit_string = 248 [json_name = "BitString"];
inline bool Node::has_bit_string() const {
  return node_case() == kBitString;
}
inline bool Node::_internal_has_bit_string() const {
  return node_case() == kBitString;
}
inline void Node::set_has_bit_string() {
  _impl_._oneof_case_[0] = kBitString;
}
inline void Node::clear_bit_string() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kBitString) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kBitString) {
    clear_has_node();
    auto* temp = _impl_.node_.bit_string_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.bit_string_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::BitString& Node::_internal_bit_string() const {
  return node_case() == kBitString ? *_impl_.node_.bit_string_ : reinterpret_cast<::pg_query::BitString&>(::pg_query::_BitString_default_instance_);
}
inline const ::pg_query::BitString& Node::bit_string() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kBitString) {
    clear_has_node();
    auto* temp = _impl_.node_.bit_string_;
    _impl_.node_.bit_string_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_bit_string(::pg_query::BitString* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_bit_string();
    _impl_.node_.bit_string_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.bit_string)
}
inline ::pg_query::BitString* Node::_internal_mutable_bit_string() {
  if (node_case() != kBitString) {
    clear_node();
    set_has_bit_string();
    _impl_.node_.bit_string_ = CreateMaybeMessage<::pg_query::BitString>(GetArena());
  }
  return _impl_.node_.bit_string_;
}
inline ::pg_query::BitString* Node::mutable_bit_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::BitString* _msg = _internal_mutable_bit_string();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.bit_string)
  return _msg;
}

// .pg_query.List list = 249 [json_name = "List"];
inline bool Node::has_list() const {
  return node_case() == kList;
}
inline bool Node::_internal_has_list() const {
  return node_case() == kList;
}
inline void Node::set_has_list() {
  _impl_._oneof_case_[0] = kList;
}
inline void Node::clear_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kList) {
    if (GetArena() == nullptr) {
      delete _impl_.node_.list_;
    }
    clear_has_node();
  }
}
inline ::pg_query::List* Node::release_list() {
  // @@protoc_insertion_point(field_release:pg_query.Node.list)
  if (node_case() == kList) {
    clear_has_node();
    auto* temp = _impl_.node_.list_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::List& Node::_internal_list() const {
  return node_case() == kList ? *_impl_.node_.list_ : reinterpret_cast<::pg_query::List&>(::pg_query::_List_default_instance_);
}
inline const ::pg_query::List& Node::list() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kList) {
    clear_has_node();
    auto* temp = _impl_.node_.list_;
    _impl_.node_.list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_list(::pg_query::List* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_list();
    _impl_.node_.list_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.list)
}
inline ::pg_query::List* Node::_internal_mutable_list() {
  if (node_case() != kList) {
    clear_node();
    set_has_list();
    _impl_.node_.list_ = CreateMaybeMessage<::pg_query::List>(GetArena());
  }
  return _impl_.node_.list_;
}
inline ::pg_query::List* Node::mutable_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::List* _msg = _internal_mutable_list();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.list)
  return _msg;
}

// .pg_query.IntList int_list = 250 [json_name = "IntList"];
inline bool Node::has_int_list() const {
  return node_case() == kIntList;
}
inline bool Node::_internal_has_int_list() const {
  return node_case() == kIntList;
}
inline void Node::set_has_int_list() {
  _impl_._oneof_case_[0] = kIntList;
}
inline void Node::clear_int_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kIntList) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kIntList) {
    clear_has_node();
    auto* temp = _impl_.node_.int_list_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.int_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::IntList& Node::_internal_int_list() const {
  return node_case() == kIntList ? *_impl_.node_.int_list_ : reinterpret_cast<::pg_query::IntList&>(::pg_query::_IntList_default_instance_);
}
inline const ::pg_query::IntList& Node::int_list() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kIntList) {
    clear_has_node();
    auto* temp = _impl_.node_.int_list_;
    _impl_.node_.int_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_int_list(::pg_query::IntList* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_int_list();
    _impl_.node_.int_list_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.int_list)
}
inline ::pg_query::IntList* Node::_internal_mutable_int_list() {
  if (node_case() != kIntList) {
    clear_node();
    set_has_int_list();
    _impl_.node_.int_list_ = CreateMaybeMessage<::pg_query::IntList>(GetArena());
  }
  return _impl_.node_.int_list_;
}
inline ::pg_query::IntList* Node::mutable_int_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::IntList* _msg = _internal_mutable_int_list();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.int_list)
  return _msg;
}

// .pg_query.OidList oid_list = 251 [json_name = "OidList"];
inline bool Node::has_oid_list() const {
  return node_case() == kOidList;
}
inline bool Node::_internal_has_oid_list() const {
  return node_case() == kOidList;
}
inline void Node::set_has_oid_list() {
  _impl_._oneof_case_[0] = kOidList;
}
inline void Node::clear_oid_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kOidList) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kOidList) {
    clear_has_node();
    auto* temp = _impl_.node_.oid_list_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.oid_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::OidList& Node::_internal_oid_list() const {
  return node_case() == kOidList ? *_impl_.node_.oid_list_ : reinterpret_cast<::pg_query::OidList&>(::pg_query::_OidList_default_instance_);
}
inline const ::pg_query::OidList& Node::oid_list() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kOidList) {
    clear_has_node();
    auto* temp = _impl_.node_.oid_list_;
    _impl_.node_.oid_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_oid_list(::pg_query::OidList* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_oid_list();
    _impl_.node_.oid_list_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.oid_list)
}
inline ::pg_query::OidList* Node::_internal_mutable_oid_list() {
  if (node_case() != kOidList) {
    clear_node();
    set_has_oid_list();
    _impl_.node_.oid_list_ = CreateMaybeMessage<::pg_query::OidList>(GetArena());
  }
  return _impl_.node_.oid_list_;
}
inline ::pg_query::OidList* Node::mutable_oid_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::OidList* _msg = _internal_mutable_oid_list();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.oid_list)
  return _msg;
}

// .pg_query.A_Const a_const = 252 [json_name = "A_Const"];
inline bool Node::has_a_const() const {
  return node_case() == kAConst;
}
inline bool Node::_internal_has_a_const() const {
  return node_case() == kAConst;
}
inline void Node::set_has_a_const() {
  _impl_._oneof_case_[0] = kAConst;
}
inline void Node::clear_a_const() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (node_case() == kAConst) {
    if (GetArena() == nullptr) {
      delete _impl_.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 (node_case() == kAConst) {
    clear_has_node();
    auto* temp = _impl_.node_.a_const_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.node_.a_const_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::A_Const& Node::_internal_a_const() const {
  return node_case() == kAConst ? *_impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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 (node_case() == kAConst) {
    clear_has_node();
    auto* temp = _impl_.node_.a_const_;
    _impl_.node_.a_const_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node::unsafe_arena_set_allocated_a_const(::pg_query::A_Const* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_node();
  if (value) {
    set_has_a_const();
    _impl_.node_.a_const_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_const)
}
inline ::pg_query::A_Const* Node::_internal_mutable_a_const() {
  if (node_case() != kAConst) {
    clear_node();
    set_has_a_const();
    _impl_.node_.a_const_ = CreateMaybeMessage<::pg_query::A_Const>(GetArena());
  }
  return _impl_.node_.a_const_;
}
inline ::pg_query::A_Const* Node::mutable_a_const() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::A_Const* _msg = _internal_mutable_a_const();
  // @@protoc_insertion_point(field_mutable:pg_query.Node.a_const)
  return _msg;
}

inline bool Node::has_node() const {
  return node_case() != NODE_NOT_SET;
}
inline void Node::clear_has_node() {
  _impl_._oneof_case_[0] = NODE_NOT_SET;
}
inline Node::NodeCase Node::node_case() const {
  return Node::NodeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Integer

// int32 ival = 1;
inline void Integer::clear_ival() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ival_ = 0;
}
inline ::int32_t Integer::ival() const {
  // @@protoc_insertion_point(field_get:pg_query.Integer.ival)
  return _internal_ival();
}
inline void Integer::set_ival(::int32_t value) {
  _internal_set_ival(value);
  // @@protoc_insertion_point(field_set:pg_query.Integer.ival)
}
inline ::int32_t Integer::_internal_ival() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ival_;
}
inline void Integer::_internal_set_ival(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ival_ = value;
}

// -------------------------------------------------------------------

// Float

// string fval = 1;
inline void Float::clear_fval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fval_.ClearToEmpty();
}
inline const std::string& Float::fval() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Float.fval)
  return _internal_fval();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Float::set_fval(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fval_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.Float.fval)
}
inline std::string* Float::mutable_fval() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_fval();
  // @@protoc_insertion_point(field_mutable:pg_query.Float.fval)
  return _s;
}
inline const std::string& Float::_internal_fval() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fval_.Get();
}
inline void Float::_internal_set_fval(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fval_.Set(value, GetArena());
}
inline std::string* Float::_internal_mutable_fval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.fval_.Mutable( GetArena());
}
inline std::string* Float::release_fval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Float.fval)
  return _impl_.fval_.Release();
}
inline void Float::set_allocated_fval(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fval_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.fval_.IsDefault()) {
          _impl_.fval_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.Float.fval)
}

// -------------------------------------------------------------------

// Boolean

// bool boolval = 1;
inline void Boolean::clear_boolval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.boolval_ = false;
}
inline bool Boolean::boolval() const {
  // @@protoc_insertion_point(field_get:pg_query.Boolean.boolval)
  return _internal_boolval();
}
inline void Boolean::set_boolval(bool value) {
  _internal_set_boolval(value);
  // @@protoc_insertion_point(field_set:pg_query.Boolean.boolval)
}
inline bool Boolean::_internal_boolval() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.boolval_;
}
inline void Boolean::_internal_set_boolval(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.boolval_ = value;
}

// -------------------------------------------------------------------

// String

// string sval = 1;
inline void String::clear_sval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.sval_.ClearToEmpty();
}
inline const std::string& String::sval() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.String.sval)
  return _internal_sval();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void String::set_sval(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.sval_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.String.sval)
}
inline std::string* String::mutable_sval() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_sval();
  // @@protoc_insertion_point(field_mutable:pg_query.String.sval)
  return _s;
}
inline const std::string& String::_internal_sval() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.sval_.Get();
}
inline void String::_internal_set_sval(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.sval_.Set(value, GetArena());
}
inline std::string* String::_internal_mutable_sval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.sval_.Mutable( GetArena());
}
inline std::string* String::release_sval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.String.sval)
  return _impl_.sval_.Release();
}
inline void String::set_allocated_sval(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.sval_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.sval_.IsDefault()) {
          _impl_.sval_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.String.sval)
}

// -------------------------------------------------------------------

// BitString

// string bsval = 1;
inline void BitString::clear_bsval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.bsval_.ClearToEmpty();
}
inline const std::string& BitString::bsval() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.BitString.bsval)
  return _internal_bsval();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void BitString::set_bsval(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.bsval_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.BitString.bsval)
}
inline std::string* BitString::mutable_bsval() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_bsval();
  // @@protoc_insertion_point(field_mutable:pg_query.BitString.bsval)
  return _s;
}
inline const std::string& BitString::_internal_bsval() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.bsval_.Get();
}
inline void BitString::_internal_set_bsval(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.bsval_.Set(value, GetArena());
}
inline std::string* BitString::_internal_mutable_bsval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.bsval_.Mutable( GetArena());
}
inline std::string* BitString::release_bsval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.BitString.bsval)
  return _impl_.bsval_.Release();
}
inline void BitString::set_allocated_bsval(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.bsval_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.bsval_.IsDefault()) {
          _impl_.bsval_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.BitString.bsval)
}

// -------------------------------------------------------------------

// List

// repeated .pg_query.Node items = 1;
inline int List::_internal_items_size() const {
  return _internal_items().size();
}
inline int List::items_size() const {
  return _internal_items_size();
}
inline void List::clear_items() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.items_.Clear();
}
inline ::pg_query::Node* List::mutable_items(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.List.items)
  return _internal_mutable_items()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* List::mutable_items()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.List.items)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_items();
}
inline const ::pg_query::Node& List::items(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.List.items)
  return _internal_items().Get(index);
}
inline ::pg_query::Node* List::add_items() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_items()->Add();
  // @@protoc_insertion_point(field_add:pg_query.List.items)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& List::items() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.List.items)
  return _internal_items();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
List::_internal_items() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.items_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
List::_internal_mutable_items() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.items_;
}

// -------------------------------------------------------------------

// OidList

// repeated .pg_query.Node items = 1;
inline int OidList::_internal_items_size() const {
  return _internal_items().size();
}
inline int OidList::items_size() const {
  return _internal_items_size();
}
inline void OidList::clear_items() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.items_.Clear();
}
inline ::pg_query::Node* OidList::mutable_items(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.OidList.items)
  return _internal_mutable_items()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* OidList::mutable_items()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.OidList.items)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_items();
}
inline const ::pg_query::Node& OidList::items(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.OidList.items)
  return _internal_items().Get(index);
}
inline ::pg_query::Node* OidList::add_items() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_items()->Add();
  // @@protoc_insertion_point(field_add:pg_query.OidList.items)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& OidList::items() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.OidList.items)
  return _internal_items();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
OidList::_internal_items() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.items_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
OidList::_internal_mutable_items() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.items_;
}

// -------------------------------------------------------------------

// IntList

// repeated .pg_query.Node items = 1;
inline int IntList::_internal_items_size() const {
  return _internal_items().size();
}
inline int IntList::items_size() const {
  return _internal_items_size();
}
inline void IntList::clear_items() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.items_.Clear();
}
inline ::pg_query::Node* IntList::mutable_items(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.IntList.items)
  return _internal_mutable_items()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* IntList::mutable_items()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IntList.items)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_items();
}
inline const ::pg_query::Node& IntList::items(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IntList.items)
  return _internal_items().Get(index);
}
inline ::pg_query::Node* IntList::add_items() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_items()->Add();
  // @@protoc_insertion_point(field_add:pg_query.IntList.items)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& IntList::items() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.IntList.items)
  return _internal_items();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
IntList::_internal_items() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.items_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
IntList::_internal_mutable_items() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.items_;
}

// -------------------------------------------------------------------

// A_Const

// .pg_query.Integer ival = 1;
inline bool A_Const::has_ival() const {
  return val_case() == kIval;
}
inline bool A_Const::_internal_has_ival() const {
  return val_case() == kIval;
}
inline void A_Const::set_has_ival() {
  _impl_._oneof_case_[0] = kIval;
}
inline void A_Const::clear_ival() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (val_case() == kIval) {
    if (GetArena() == nullptr) {
      delete _impl_.val_.ival_;
    }
    clear_has_val();
  }
}
inline ::pg_query::Integer* A_Const::release_ival() {
  // @@protoc_insertion_point(field_release:pg_query.A_Const.ival)
  if (val_case() == kIval) {
    clear_has_val();
    auto* temp = _impl_.val_.ival_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.val_.ival_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Integer& A_Const::_internal_ival() const {
  return val_case() == kIval ? *_impl_.val_.ival_ : reinterpret_cast<::pg_query::Integer&>(::pg_query::_Integer_default_instance_);
}
inline const ::pg_query::Integer& A_Const::ival() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.A_Const.ival)
  return _internal_ival();
}
inline ::pg_query::Integer* A_Const::unsafe_arena_release_ival() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.A_Const.ival)
  if (val_case() == kIval) {
    clear_has_val();
    auto* temp = _impl_.val_.ival_;
    _impl_.val_.ival_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void A_Const::unsafe_arena_set_allocated_ival(::pg_query::Integer* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_val();
  if (value) {
    set_has_ival();
    _impl_.val_.ival_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Const.ival)
}
inline ::pg_query::Integer* A_Const::_internal_mutable_ival() {
  if (val_case() != kIval) {
    clear_val();
    set_has_ival();
    _impl_.val_.ival_ = CreateMaybeMessage<::pg_query::Integer>(GetArena());
  }
  return _impl_.val_.ival_;
}
inline ::pg_query::Integer* A_Const::mutable_ival() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Integer* _msg = _internal_mutable_ival();
  // @@protoc_insertion_point(field_mutable:pg_query.A_Const.ival)
  return _msg;
}

// .pg_query.Float fval = 2;
inline bool A_Const::has_fval() const {
  return val_case() == kFval;
}
inline bool A_Const::_internal_has_fval() const {
  return val_case() == kFval;
}
inline void A_Const::set_has_fval() {
  _impl_._oneof_case_[0] = kFval;
}
inline void A_Const::clear_fval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (val_case() == kFval) {
    if (GetArena() == nullptr) {
      delete _impl_.val_.fval_;
    }
    clear_has_val();
  }
}
inline ::pg_query::Float* A_Const::release_fval() {
  // @@protoc_insertion_point(field_release:pg_query.A_Const.fval)
  if (val_case() == kFval) {
    clear_has_val();
    auto* temp = _impl_.val_.fval_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.val_.fval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Float& A_Const::_internal_fval() const {
  return val_case() == kFval ? *_impl_.val_.fval_ : reinterpret_cast<::pg_query::Float&>(::pg_query::_Float_default_instance_);
}
inline const ::pg_query::Float& A_Const::fval() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.A_Const.fval)
  return _internal_fval();
}
inline ::pg_query::Float* A_Const::unsafe_arena_release_fval() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.A_Const.fval)
  if (val_case() == kFval) {
    clear_has_val();
    auto* temp = _impl_.val_.fval_;
    _impl_.val_.fval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void A_Const::unsafe_arena_set_allocated_fval(::pg_query::Float* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_val();
  if (value) {
    set_has_fval();
    _impl_.val_.fval_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Const.fval)
}
inline ::pg_query::Float* A_Const::_internal_mutable_fval() {
  if (val_case() != kFval) {
    clear_val();
    set_has_fval();
    _impl_.val_.fval_ = CreateMaybeMessage<::pg_query::Float>(GetArena());
  }
  return _impl_.val_.fval_;
}
inline ::pg_query::Float* A_Const::mutable_fval() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Float* _msg = _internal_mutable_fval();
  // @@protoc_insertion_point(field_mutable:pg_query.A_Const.fval)
  return _msg;
}

// .pg_query.Boolean boolval = 3;
inline bool A_Const::has_boolval() const {
  return val_case() == kBoolval;
}
inline bool A_Const::_internal_has_boolval() const {
  return val_case() == kBoolval;
}
inline void A_Const::set_has_boolval() {
  _impl_._oneof_case_[0] = kBoolval;
}
inline void A_Const::clear_boolval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (val_case() == kBoolval) {
    if (GetArena() == nullptr) {
      delete _impl_.val_.boolval_;
    }
    clear_has_val();
  }
}
inline ::pg_query::Boolean* A_Const::release_boolval() {
  // @@protoc_insertion_point(field_release:pg_query.A_Const.boolval)
  if (val_case() == kBoolval) {
    clear_has_val();
    auto* temp = _impl_.val_.boolval_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.val_.boolval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::Boolean& A_Const::_internal_boolval() const {
  return val_case() == kBoolval ? *_impl_.val_.boolval_ : reinterpret_cast<::pg_query::Boolean&>(::pg_query::_Boolean_default_instance_);
}
inline const ::pg_query::Boolean& A_Const::boolval() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.A_Const.boolval)
  return _internal_boolval();
}
inline ::pg_query::Boolean* A_Const::unsafe_arena_release_boolval() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.A_Const.boolval)
  if (val_case() == kBoolval) {
    clear_has_val();
    auto* temp = _impl_.val_.boolval_;
    _impl_.val_.boolval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void A_Const::unsafe_arena_set_allocated_boolval(::pg_query::Boolean* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_val();
  if (value) {
    set_has_boolval();
    _impl_.val_.boolval_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Const.boolval)
}
inline ::pg_query::Boolean* A_Const::_internal_mutable_boolval() {
  if (val_case() != kBoolval) {
    clear_val();
    set_has_boolval();
    _impl_.val_.boolval_ = CreateMaybeMessage<::pg_query::Boolean>(GetArena());
  }
  return _impl_.val_.boolval_;
}
inline ::pg_query::Boolean* A_Const::mutable_boolval() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Boolean* _msg = _internal_mutable_boolval();
  // @@protoc_insertion_point(field_mutable:pg_query.A_Const.boolval)
  return _msg;
}

// .pg_query.String sval = 4;
inline bool A_Const::has_sval() const {
  return val_case() == kSval;
}
inline bool A_Const::_internal_has_sval() const {
  return val_case() == kSval;
}
inline void A_Const::set_has_sval() {
  _impl_._oneof_case_[0] = kSval;
}
inline void A_Const::clear_sval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (val_case() == kSval) {
    if (GetArena() == nullptr) {
      delete _impl_.val_.sval_;
    }
    clear_has_val();
  }
}
inline ::pg_query::String* A_Const::release_sval() {
  // @@protoc_insertion_point(field_release:pg_query.A_Const.sval)
  if (val_case() == kSval) {
    clear_has_val();
    auto* temp = _impl_.val_.sval_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.val_.sval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::String& A_Const::_internal_sval() const {
  return val_case() == kSval ? *_impl_.val_.sval_ : reinterpret_cast<::pg_query::String&>(::pg_query::_String_default_instance_);
}
inline const ::pg_query::String& A_Const::sval() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.A_Const.sval)
  return _internal_sval();
}
inline ::pg_query::String* A_Const::unsafe_arena_release_sval() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.A_Const.sval)
  if (val_case() == kSval) {
    clear_has_val();
    auto* temp = _impl_.val_.sval_;
    _impl_.val_.sval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void A_Const::unsafe_arena_set_allocated_sval(::pg_query::String* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_val();
  if (value) {
    set_has_sval();
    _impl_.val_.sval_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Const.sval)
}
inline ::pg_query::String* A_Const::_internal_mutable_sval() {
  if (val_case() != kSval) {
    clear_val();
    set_has_sval();
    _impl_.val_.sval_ = CreateMaybeMessage<::pg_query::String>(GetArena());
  }
  return _impl_.val_.sval_;
}
inline ::pg_query::String* A_Const::mutable_sval() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::String* _msg = _internal_mutable_sval();
  // @@protoc_insertion_point(field_mutable:pg_query.A_Const.sval)
  return _msg;
}

// .pg_query.BitString bsval = 5;
inline bool A_Const::has_bsval() const {
  return val_case() == kBsval;
}
inline bool A_Const::_internal_has_bsval() const {
  return val_case() == kBsval;
}
inline void A_Const::set_has_bsval() {
  _impl_._oneof_case_[0] = kBsval;
}
inline void A_Const::clear_bsval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (val_case() == kBsval) {
    if (GetArena() == nullptr) {
      delete _impl_.val_.bsval_;
    }
    clear_has_val();
  }
}
inline ::pg_query::BitString* A_Const::release_bsval() {
  // @@protoc_insertion_point(field_release:pg_query.A_Const.bsval)
  if (val_case() == kBsval) {
    clear_has_val();
    auto* temp = _impl_.val_.bsval_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.val_.bsval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pg_query::BitString& A_Const::_internal_bsval() const {
  return val_case() == kBsval ? *_impl_.val_.bsval_ : reinterpret_cast<::pg_query::BitString&>(::pg_query::_BitString_default_instance_);
}
inline const ::pg_query::BitString& A_Const::bsval() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.A_Const.bsval)
  return _internal_bsval();
}
inline ::pg_query::BitString* A_Const::unsafe_arena_release_bsval() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.A_Const.bsval)
  if (val_case() == kBsval) {
    clear_has_val();
    auto* temp = _impl_.val_.bsval_;
    _impl_.val_.bsval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void A_Const::unsafe_arena_set_allocated_bsval(::pg_query::BitString* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_val();
  if (value) {
    set_has_bsval();
    _impl_.val_.bsval_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Const.bsval)
}
inline ::pg_query::BitString* A_Const::_internal_mutable_bsval() {
  if (val_case() != kBsval) {
    clear_val();
    set_has_bsval();
    _impl_.val_.bsval_ = CreateMaybeMessage<::pg_query::BitString>(GetArena());
  }
  return _impl_.val_.bsval_;
}
inline ::pg_query::BitString* A_Const::mutable_bsval() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::BitString* _msg = _internal_mutable_bsval();
  // @@protoc_insertion_point(field_mutable:pg_query.A_Const.bsval)
  return _msg;
}

// bool isnull = 10;
inline void A_Const::clear_isnull() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.isnull_ = false;
}
inline bool A_Const::isnull() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Const.isnull)
  return _internal_isnull();
}
inline void A_Const::set_isnull(bool value) {
  _internal_set_isnull(value);
  // @@protoc_insertion_point(field_set:pg_query.A_Const.isnull)
}
inline bool A_Const::_internal_isnull() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.isnull_;
}
inline void A_Const::_internal_set_isnull(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.isnull_ = value;
}

// int32 location = 11;
inline void A_Const::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t A_Const::location() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Const.location)
  return _internal_location();
}
inline void A_Const::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.A_Const.location)
}
inline ::int32_t A_Const::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void A_Const::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

inline bool A_Const::has_val() const {
  return val_case() != VAL_NOT_SET;
}
inline void A_Const::clear_has_val() {
  _impl_._oneof_case_[0] = VAL_NOT_SET;
}
inline A_Const::ValCase A_Const::val_case() const {
  return A_Const::ValCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Alias

// string aliasname = 1 [json_name = "aliasname"];
inline void Alias::clear_aliasname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aliasname_.ClearToEmpty();
}
inline const std::string& Alias::aliasname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Alias.aliasname)
  return _internal_aliasname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Alias::set_aliasname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.aliasname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.Alias.aliasname)
}
inline std::string* Alias::mutable_aliasname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_aliasname();
  // @@protoc_insertion_point(field_mutable:pg_query.Alias.aliasname)
  return _s;
}
inline const std::string& Alias::_internal_aliasname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aliasname_.Get();
}
inline void Alias::_internal_set_aliasname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.aliasname_.Set(value, GetArena());
}
inline std::string* Alias::_internal_mutable_aliasname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.aliasname_.Mutable( GetArena());
}
inline std::string* Alias::release_aliasname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Alias.aliasname)
  return _impl_.aliasname_.Release();
}
inline void Alias::set_allocated_aliasname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aliasname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.aliasname_.IsDefault()) {
          _impl_.aliasname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_colnames().size();
}
inline int Alias::colnames_size() const {
  return _internal_colnames_size();
}
inline void Alias::clear_colnames() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.colnames_.Clear();
}
inline ::pg_query::Node* Alias::mutable_colnames(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Alias.colnames)
  return _internal_mutable_colnames()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Alias::mutable_colnames()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Alias.colnames)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_colnames();
}
inline const ::pg_query::Node& Alias::colnames(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Alias.colnames)
  return _internal_colnames().Get(index);
}
inline ::pg_query::Node* Alias::add_colnames() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_colnames()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Alias.colnames)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Alias::colnames() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Alias.colnames)
  return _internal_colnames();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Alias::_internal_colnames() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.colnames_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Alias::_internal_mutable_colnames() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.colnames_;
}

// -------------------------------------------------------------------

// RangeVar

// string catalogname = 1 [json_name = "catalogname"];
inline void RangeVar::clear_catalogname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.catalogname_.ClearToEmpty();
}
inline const std::string& RangeVar::catalogname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.catalogname)
  return _internal_catalogname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RangeVar::set_catalogname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.catalogname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.RangeVar.catalogname)
}
inline std::string* RangeVar::mutable_catalogname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_catalogname();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeVar.catalogname)
  return _s;
}
inline const std::string& RangeVar::_internal_catalogname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.catalogname_.Get();
}
inline void RangeVar::_internal_set_catalogname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.catalogname_.Set(value, GetArena());
}
inline std::string* RangeVar::_internal_mutable_catalogname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.catalogname_.Mutable( GetArena());
}
inline std::string* RangeVar::release_catalogname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeVar.catalogname)
  return _impl_.catalogname_.Release();
}
inline void RangeVar::set_allocated_catalogname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.catalogname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.catalogname_.IsDefault()) {
          _impl_.catalogname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeVar.catalogname)
}

// string schemaname = 2 [json_name = "schemaname"];
inline void RangeVar::clear_schemaname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.schemaname_.ClearToEmpty();
}
inline const std::string& RangeVar::schemaname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.schemaname)
  return _internal_schemaname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RangeVar::set_schemaname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.schemaname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.RangeVar.schemaname)
}
inline std::string* RangeVar::mutable_schemaname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_schemaname();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeVar.schemaname)
  return _s;
}
inline const std::string& RangeVar::_internal_schemaname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.schemaname_.Get();
}
inline void RangeVar::_internal_set_schemaname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.schemaname_.Set(value, GetArena());
}
inline std::string* RangeVar::_internal_mutable_schemaname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.schemaname_.Mutable( GetArena());
}
inline std::string* RangeVar::release_schemaname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeVar.schemaname)
  return _impl_.schemaname_.Release();
}
inline void RangeVar::set_allocated_schemaname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.schemaname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.schemaname_.IsDefault()) {
          _impl_.schemaname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeVar.schemaname)
}

// string relname = 3 [json_name = "relname"];
inline void RangeVar::clear_relname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relname_.ClearToEmpty();
}
inline const std::string& RangeVar::relname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.relname)
  return _internal_relname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RangeVar::set_relname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.RangeVar.relname)
}
inline std::string* RangeVar::mutable_relname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_relname();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeVar.relname)
  return _s;
}
inline const std::string& RangeVar::_internal_relname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.relname_.Get();
}
inline void RangeVar::_internal_set_relname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relname_.Set(value, GetArena());
}
inline std::string* RangeVar::_internal_mutable_relname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.relname_.Mutable( GetArena());
}
inline std::string* RangeVar::release_relname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeVar.relname)
  return _impl_.relname_.Release();
}
inline void RangeVar::set_allocated_relname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.relname_.IsDefault()) {
          _impl_.relname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeVar.relname)
}

// bool inh = 4 [json_name = "inh"];
inline void RangeVar::clear_inh() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inh_ = false;
}
inline bool RangeVar::inh() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.inh)
  return _internal_inh();
}
inline void RangeVar::set_inh(bool value) {
  _internal_set_inh(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeVar.inh)
}
inline bool RangeVar::_internal_inh() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inh_;
}
inline void RangeVar::_internal_set_inh(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inh_ = value;
}

// string relpersistence = 5 [json_name = "relpersistence"];
inline void RangeVar::clear_relpersistence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relpersistence_.ClearToEmpty();
}
inline const std::string& RangeVar::relpersistence() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.relpersistence)
  return _internal_relpersistence();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RangeVar::set_relpersistence(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relpersistence_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.RangeVar.relpersistence)
}
inline std::string* RangeVar::mutable_relpersistence() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_relpersistence();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeVar.relpersistence)
  return _s;
}
inline const std::string& RangeVar::_internal_relpersistence() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.relpersistence_.Get();
}
inline void RangeVar::_internal_set_relpersistence(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relpersistence_.Set(value, GetArena());
}
inline std::string* RangeVar::_internal_mutable_relpersistence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.relpersistence_.Mutable( GetArena());
}
inline std::string* RangeVar::release_relpersistence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeVar.relpersistence)
  return _impl_.relpersistence_.Release();
}
inline void RangeVar::set_allocated_relpersistence(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relpersistence_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.relpersistence_.IsDefault()) {
          _impl_.relpersistence_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeVar.relpersistence)
}

// .pg_query.Alias alias = 6 [json_name = "alias"];
inline bool RangeVar::has_alias() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.alias_ != nullptr);
  return value;
}
inline void RangeVar::clear_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.alias_ != nullptr) _impl_.alias_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Alias& RangeVar::_internal_alias() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Alias* p = _impl_.alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeVar::alias() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.alias)
  return _internal_alias();
}
inline void RangeVar::unsafe_arena_set_allocated_alias(::pg_query::Alias* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.alias_);
  }
  _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeVar.alias)
}
inline ::pg_query::Alias* RangeVar::release_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Alias* released = _impl_.alias_;
  _impl_.alias_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Alias* RangeVar::unsafe_arena_release_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeVar.alias)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Alias* temp = _impl_.alias_;
  _impl_.alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeVar::_internal_mutable_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(p);
  }
  return _impl_.alias_;
}
inline ::pg_query::Alias* RangeVar::mutable_alias() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Alias* _msg = _internal_mutable_alias();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeVar.alias)
  return _msg;
}
inline void RangeVar::set_allocated_alias(::pg_query::Alias* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Alias*>(_impl_.alias_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Alias*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeVar.alias)
}

// int32 location = 7 [json_name = "location"];
inline void RangeVar::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t RangeVar::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeVar.location)
  return _internal_location();
}
inline void RangeVar::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeVar.location)
}
inline ::int32_t RangeVar::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void RangeVar::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// TableFunc

// repeated .pg_query.Node ns_uris = 1 [json_name = "ns_uris"];
inline int TableFunc::_internal_ns_uris_size() const {
  return _internal_ns_uris().size();
}
inline int TableFunc::ns_uris_size() const {
  return _internal_ns_uris_size();
}
inline void TableFunc::clear_ns_uris() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ns_uris_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_ns_uris(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.ns_uris)
  return _internal_mutable_ns_uris()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TableFunc::mutable_ns_uris()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.ns_uris)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_ns_uris();
}
inline const ::pg_query::Node& TableFunc::ns_uris(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.ns_uris)
  return _internal_ns_uris().Get(index);
}
inline ::pg_query::Node* TableFunc::add_ns_uris() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_ns_uris()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.ns_uris)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TableFunc::ns_uris() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.ns_uris)
  return _internal_ns_uris();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TableFunc::_internal_ns_uris() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ns_uris_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TableFunc::_internal_mutable_ns_uris() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.ns_uris_;
}

// repeated .pg_query.Node ns_names = 2 [json_name = "ns_names"];
inline int TableFunc::_internal_ns_names_size() const {
  return _internal_ns_names().size();
}
inline int TableFunc::ns_names_size() const {
  return _internal_ns_names_size();
}
inline void TableFunc::clear_ns_names() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ns_names_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_ns_names(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.ns_names)
  return _internal_mutable_ns_names()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TableFunc::mutable_ns_names()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.ns_names)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_ns_names();
}
inline const ::pg_query::Node& TableFunc::ns_names(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.ns_names)
  return _internal_ns_names().Get(index);
}
inline ::pg_query::Node* TableFunc::add_ns_names() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_ns_names()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.ns_names)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TableFunc::ns_names() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.ns_names)
  return _internal_ns_names();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TableFunc::_internal_ns_names() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ns_names_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TableFunc::_internal_mutable_ns_names() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.ns_names_;
}

// .pg_query.Node docexpr = 3 [json_name = "docexpr"];
inline bool TableFunc::has_docexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.docexpr_ != nullptr);
  return value;
}
inline void TableFunc::clear_docexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.docexpr_ != nullptr) _impl_.docexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& TableFunc::_internal_docexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.docexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& TableFunc::docexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.docexpr)
  return _internal_docexpr();
}
inline void TableFunc::unsafe_arena_set_allocated_docexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.docexpr_);
  }
  _impl_.docexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TableFunc.docexpr)
}
inline ::pg_query::Node* TableFunc::release_docexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.docexpr_;
  _impl_.docexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* TableFunc::unsafe_arena_release_docexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.TableFunc.docexpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.docexpr_;
  _impl_.docexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* TableFunc::_internal_mutable_docexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.docexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.docexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.docexpr_;
}
inline ::pg_query::Node* TableFunc::mutable_docexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_docexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.docexpr)
  return _msg;
}
inline void TableFunc::set_allocated_docexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.docexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.docexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.TableFunc.docexpr)
}

// .pg_query.Node rowexpr = 4 [json_name = "rowexpr"];
inline bool TableFunc::has_rowexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.rowexpr_ != nullptr);
  return value;
}
inline void TableFunc::clear_rowexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.rowexpr_ != nullptr) _impl_.rowexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& TableFunc::_internal_rowexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.rowexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& TableFunc::rowexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.rowexpr)
  return _internal_rowexpr();
}
inline void TableFunc::unsafe_arena_set_allocated_rowexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.rowexpr_);
  }
  _impl_.rowexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TableFunc.rowexpr)
}
inline ::pg_query::Node* TableFunc::release_rowexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.rowexpr_;
  _impl_.rowexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* TableFunc::unsafe_arena_release_rowexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.TableFunc.rowexpr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.rowexpr_;
  _impl_.rowexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* TableFunc::_internal_mutable_rowexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.rowexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.rowexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.rowexpr_;
}
inline ::pg_query::Node* TableFunc::mutable_rowexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_rowexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.rowexpr)
  return _msg;
}
inline void TableFunc::set_allocated_rowexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.rowexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.rowexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_colnames().size();
}
inline int TableFunc::colnames_size() const {
  return _internal_colnames_size();
}
inline void TableFunc::clear_colnames() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.colnames_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_colnames(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.colnames)
  return _internal_mutable_colnames()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TableFunc::mutable_colnames()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.colnames)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_colnames();
}
inline const ::pg_query::Node& TableFunc::colnames(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.colnames)
  return _internal_colnames().Get(index);
}
inline ::pg_query::Node* TableFunc::add_colnames() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_colnames()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.colnames)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TableFunc::colnames() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.colnames)
  return _internal_colnames();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TableFunc::_internal_colnames() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.colnames_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TableFunc::_internal_mutable_colnames() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.colnames_;
}

// repeated .pg_query.Node coltypes = 6 [json_name = "coltypes"];
inline int TableFunc::_internal_coltypes_size() const {
  return _internal_coltypes().size();
}
inline int TableFunc::coltypes_size() const {
  return _internal_coltypes_size();
}
inline void TableFunc::clear_coltypes() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coltypes_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_coltypes(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.coltypes)
  return _internal_mutable_coltypes()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TableFunc::mutable_coltypes()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.coltypes)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_coltypes();
}
inline const ::pg_query::Node& TableFunc::coltypes(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.coltypes)
  return _internal_coltypes().Get(index);
}
inline ::pg_query::Node* TableFunc::add_coltypes() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_coltypes()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.coltypes)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TableFunc::coltypes() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.coltypes)
  return _internal_coltypes();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TableFunc::_internal_coltypes() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.coltypes_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TableFunc::_internal_mutable_coltypes() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.coltypes_;
}

// repeated .pg_query.Node coltypmods = 7 [json_name = "coltypmods"];
inline int TableFunc::_internal_coltypmods_size() const {
  return _internal_coltypmods().size();
}
inline int TableFunc::coltypmods_size() const {
  return _internal_coltypmods_size();
}
inline void TableFunc::clear_coltypmods() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coltypmods_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_coltypmods(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.coltypmods)
  return _internal_mutable_coltypmods()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TableFunc::mutable_coltypmods()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.coltypmods)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_coltypmods();
}
inline const ::pg_query::Node& TableFunc::coltypmods(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.coltypmods)
  return _internal_coltypmods().Get(index);
}
inline ::pg_query::Node* TableFunc::add_coltypmods() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_coltypmods()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.coltypmods)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TableFunc::coltypmods() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.coltypmods)
  return _internal_coltypmods();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TableFunc::_internal_coltypmods() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.coltypmods_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TableFunc::_internal_mutable_coltypmods() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.coltypmods_;
}

// repeated .pg_query.Node colcollations = 8 [json_name = "colcollations"];
inline int TableFunc::_internal_colcollations_size() const {
  return _internal_colcollations().size();
}
inline int TableFunc::colcollations_size() const {
  return _internal_colcollations_size();
}
inline void TableFunc::clear_colcollations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.colcollations_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_colcollations(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.colcollations)
  return _internal_mutable_colcollations()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TableFunc::mutable_colcollations()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.colcollations)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_colcollations();
}
inline const ::pg_query::Node& TableFunc::colcollations(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.colcollations)
  return _internal_colcollations().Get(index);
}
inline ::pg_query::Node* TableFunc::add_colcollations() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_colcollations()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.colcollations)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TableFunc::colcollations() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.colcollations)
  return _internal_colcollations();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TableFunc::_internal_colcollations() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.colcollations_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TableFunc::_internal_mutable_colcollations() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.colcollations_;
}

// repeated .pg_query.Node colexprs = 9 [json_name = "colexprs"];
inline int TableFunc::_internal_colexprs_size() const {
  return _internal_colexprs().size();
}
inline int TableFunc::colexprs_size() const {
  return _internal_colexprs_size();
}
inline void TableFunc::clear_colexprs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.colexprs_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_colexprs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.colexprs)
  return _internal_mutable_colexprs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TableFunc::mutable_colexprs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.colexprs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_colexprs();
}
inline const ::pg_query::Node& TableFunc::colexprs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.colexprs)
  return _internal_colexprs().Get(index);
}
inline ::pg_query::Node* TableFunc::add_colexprs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_colexprs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.colexprs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TableFunc::colexprs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.colexprs)
  return _internal_colexprs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TableFunc::_internal_colexprs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.colexprs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TableFunc::_internal_mutable_colexprs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.colexprs_;
}

// repeated .pg_query.Node coldefexprs = 10 [json_name = "coldefexprs"];
inline int TableFunc::_internal_coldefexprs_size() const {
  return _internal_coldefexprs().size();
}
inline int TableFunc::coldefexprs_size() const {
  return _internal_coldefexprs_size();
}
inline void TableFunc::clear_coldefexprs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coldefexprs_.Clear();
}
inline ::pg_query::Node* TableFunc::mutable_coldefexprs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.coldefexprs)
  return _internal_mutable_coldefexprs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TableFunc::mutable_coldefexprs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.coldefexprs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_coldefexprs();
}
inline const ::pg_query::Node& TableFunc::coldefexprs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.coldefexprs)
  return _internal_coldefexprs().Get(index);
}
inline ::pg_query::Node* TableFunc::add_coldefexprs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_coldefexprs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.coldefexprs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TableFunc::coldefexprs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.coldefexprs)
  return _internal_coldefexprs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TableFunc::_internal_coldefexprs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.coldefexprs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TableFunc::_internal_mutable_coldefexprs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.coldefexprs_;
}

// repeated uint64 notnulls = 11 [json_name = "notnulls"];
inline int TableFunc::_internal_notnulls_size() const {
  return _internal_notnulls().size();
}
inline int TableFunc::notnulls_size() const {
  return _internal_notnulls_size();
}
inline void TableFunc::clear_notnulls() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.notnulls_.Clear();
}
inline ::uint64_t TableFunc::notnulls(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.notnulls)
  return _internal_notnulls().Get(index);
}
inline void TableFunc::set_notnulls(int index, ::uint64_t value) {
  _internal_mutable_notnulls()->Set(index, value);
  // @@protoc_insertion_point(field_set:pg_query.TableFunc.notnulls)
}
inline void TableFunc::add_notnulls(::uint64_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_notnulls()->Add(value);
  // @@protoc_insertion_point(field_add:pg_query.TableFunc.notnulls)
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& TableFunc::notnulls() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TableFunc.notnulls)
  return _internal_notnulls();
}
inline ::google::protobuf::RepeatedField<::uint64_t>* TableFunc::mutable_notnulls()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.notnulls)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_notnulls();
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& TableFunc::_internal_notnulls()
    const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.notnulls_;
}
inline ::google::protobuf::RepeatedField<::uint64_t>* TableFunc::_internal_mutable_notnulls() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.notnulls_;
}

// int32 ordinalitycol = 12 [json_name = "ordinalitycol"];
inline void TableFunc::clear_ordinalitycol() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ordinalitycol_ = 0;
}
inline ::int32_t TableFunc::ordinalitycol() const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.ordinalitycol)
  return _internal_ordinalitycol();
}
inline void TableFunc::set_ordinalitycol(::int32_t value) {
  _internal_set_ordinalitycol(value);
  // @@protoc_insertion_point(field_set:pg_query.TableFunc.ordinalitycol)
}
inline ::int32_t TableFunc::_internal_ordinalitycol() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ordinalitycol_;
}
inline void TableFunc::_internal_set_ordinalitycol(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ordinalitycol_ = value;
}

// int32 location = 13 [json_name = "location"];
inline void TableFunc::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t TableFunc::location() const {
  // @@protoc_insertion_point(field_get:pg_query.TableFunc.location)
  return _internal_location();
}
inline void TableFunc::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.TableFunc.location)
}
inline ::int32_t TableFunc::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void TableFunc::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// IntoClause

// .pg_query.RangeVar rel = 1 [json_name = "rel"];
inline bool IntoClause::has_rel() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.rel_ != nullptr);
  return value;
}
inline void IntoClause::clear_rel() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.rel_ != nullptr) _impl_.rel_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& IntoClause::_internal_rel() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.rel_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& IntoClause::rel() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.rel)
  return _internal_rel();
}
inline void IntoClause::unsafe_arena_set_allocated_rel(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.rel_);
  }
  _impl_.rel_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IntoClause.rel)
}
inline ::pg_query::RangeVar* IntoClause::release_rel() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.rel_;
  _impl_.rel_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* IntoClause::unsafe_arena_release_rel() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IntoClause.rel)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.rel_;
  _impl_.rel_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* IntoClause::_internal_mutable_rel() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.rel_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.rel_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.rel_;
}
inline ::pg_query::RangeVar* IntoClause::mutable_rel() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_rel();
  // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.rel)
  return _msg;
}
inline void IntoClause::set_allocated_rel(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.rel_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.rel_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@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 _internal_col_names().size();
}
inline int IntoClause::col_names_size() const {
  return _internal_col_names_size();
}
inline void IntoClause::clear_col_names() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.col_names_.Clear();
}
inline ::pg_query::Node* IntoClause::mutable_col_names(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.col_names)
  return _internal_mutable_col_names()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* IntoClause::mutable_col_names()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IntoClause.col_names)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_col_names();
}
inline const ::pg_query::Node& IntoClause::col_names(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.col_names)
  return _internal_col_names().Get(index);
}
inline ::pg_query::Node* IntoClause::add_col_names() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_col_names()->Add();
  // @@protoc_insertion_point(field_add:pg_query.IntoClause.col_names)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& IntoClause::col_names() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.IntoClause.col_names)
  return _internal_col_names();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
IntoClause::_internal_col_names() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.col_names_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
IntoClause::_internal_mutable_col_names() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.col_names_;
}

// string access_method = 3 [json_name = "accessMethod"];
inline void IntoClause::clear_access_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.access_method_.ClearToEmpty();
}
inline const std::string& IntoClause::access_method() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.access_method)
  return _internal_access_method();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void IntoClause::set_access_method(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.access_method_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.IntoClause.access_method)
}
inline std::string* IntoClause::mutable_access_method() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_access_method();
  // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.access_method)
  return _s;
}
inline const std::string& IntoClause::_internal_access_method() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.access_method_.Get();
}
inline void IntoClause::_internal_set_access_method(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.access_method_.Set(value, GetArena());
}
inline std::string* IntoClause::_internal_mutable_access_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.access_method_.Mutable( GetArena());
}
inline std::string* IntoClause::release_access_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IntoClause.access_method)
  return _impl_.access_method_.Release();
}
inline void IntoClause::set_allocated_access_method(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.access_method_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.access_method_.IsDefault()) {
          _impl_.access_method_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int IntoClause::options_size() const {
  return _internal_options_size();
}
inline void IntoClause::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* IntoClause::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* IntoClause::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IntoClause.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& IntoClause::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* IntoClause::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.IntoClause.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& IntoClause::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.IntoClause.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
IntoClause::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
IntoClause::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// .pg_query.OnCommitAction on_commit = 5 [json_name = "onCommit"];
inline void IntoClause::clear_on_commit() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.on_commit_ = 0;
}
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::set_on_commit(::pg_query::OnCommitAction value) {
  _internal_set_on_commit(value);
  // @@protoc_insertion_point(field_set:pg_query.IntoClause.on_commit)
}
inline ::pg_query::OnCommitAction IntoClause::_internal_on_commit() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::OnCommitAction>(_impl_.on_commit_);
}
inline void IntoClause::_internal_set_on_commit(::pg_query::OnCommitAction value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.on_commit_ = value;
}

// string table_space_name = 6 [json_name = "tableSpaceName"];
inline void IntoClause::clear_table_space_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.table_space_name_.ClearToEmpty();
}
inline const std::string& IntoClause::table_space_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.table_space_name)
  return _internal_table_space_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void IntoClause::set_table_space_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.table_space_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.IntoClause.table_space_name)
}
inline std::string* IntoClause::mutable_table_space_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_table_space_name();
  // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.table_space_name)
  return _s;
}
inline const std::string& IntoClause::_internal_table_space_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.table_space_name_.Get();
}
inline void IntoClause::_internal_set_table_space_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.table_space_name_.Set(value, GetArena());
}
inline std::string* IntoClause::_internal_mutable_table_space_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.table_space_name_.Mutable( GetArena());
}
inline std::string* IntoClause::release_table_space_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IntoClause.table_space_name)
  return _impl_.table_space_name_.Release();
}
inline void IntoClause::set_allocated_table_space_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.table_space_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.table_space_name_.IsDefault()) {
          _impl_.table_space_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.IntoClause.table_space_name)
}

// .pg_query.Node view_query = 7 [json_name = "viewQuery"];
inline bool IntoClause::has_view_query() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.view_query_ != nullptr);
  return value;
}
inline void IntoClause::clear_view_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.view_query_ != nullptr) _impl_.view_query_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& IntoClause::_internal_view_query() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.view_query_);
  }
  _impl_.view_query_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IntoClause.view_query)
}
inline ::pg_query::Node* IntoClause::release_view_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.view_query_;
  _impl_.view_query_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* IntoClause::unsafe_arena_release_view_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IntoClause.view_query)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.view_query_;
  _impl_.view_query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* IntoClause::_internal_mutable_view_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.view_query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.view_query_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.view_query_;
}
inline ::pg_query::Node* IntoClause::mutable_view_query() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_view_query();
  // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.view_query)
  return _msg;
}
inline void IntoClause::set_allocated_view_query(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.view_query_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.view_query_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.IntoClause.view_query)
}

// bool skip_data = 8 [json_name = "skipData"];
inline void IntoClause::clear_skip_data() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.skip_data_ = false;
}
inline bool IntoClause::skip_data() const {
  // @@protoc_insertion_point(field_get:pg_query.IntoClause.skip_data)
  return _internal_skip_data();
}
inline void IntoClause::set_skip_data(bool value) {
  _internal_set_skip_data(value);
  // @@protoc_insertion_point(field_set:pg_query.IntoClause.skip_data)
}
inline bool IntoClause::_internal_skip_data() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.skip_data_;
}
inline void IntoClause::_internal_set_skip_data(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.skip_data_ = value;
}

// -------------------------------------------------------------------

// Var

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool Var::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void Var::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& Var::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Var::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Var.xpr)
  return _internal_xpr();
}
inline void Var::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Var.xpr)
}
inline ::pg_query::Node* Var::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* Var::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Var.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Var::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* Var::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.Var.xpr)
  return _msg;
}
inline void Var::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Var.xpr)
}

// int32 varno = 2 [json_name = "varno"];
inline void Var::clear_varno() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.varno_ = 0;
}
inline ::int32_t Var::varno() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.varno)
  return _internal_varno();
}
inline void Var::set_varno(::int32_t value) {
  _internal_set_varno(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.varno)
}
inline ::int32_t Var::_internal_varno() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.varno_;
}
inline void Var::_internal_set_varno(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.varno_ = value;
}

// int32 varattno = 3 [json_name = "varattno"];
inline void Var::clear_varattno() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.varattno_ = 0;
}
inline ::int32_t Var::varattno() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.varattno)
  return _internal_varattno();
}
inline void Var::set_varattno(::int32_t value) {
  _internal_set_varattno(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.varattno)
}
inline ::int32_t Var::_internal_varattno() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.varattno_;
}
inline void Var::_internal_set_varattno(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.varattno_ = value;
}

// uint32 vartype = 4 [json_name = "vartype"];
inline void Var::clear_vartype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.vartype_ = 0u;
}
inline ::uint32_t Var::vartype() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.vartype)
  return _internal_vartype();
}
inline void Var::set_vartype(::uint32_t value) {
  _internal_set_vartype(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.vartype)
}
inline ::uint32_t Var::_internal_vartype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.vartype_;
}
inline void Var::_internal_set_vartype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.vartype_ = value;
}

// int32 vartypmod = 5 [json_name = "vartypmod"];
inline void Var::clear_vartypmod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.vartypmod_ = 0;
}
inline ::int32_t Var::vartypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.vartypmod)
  return _internal_vartypmod();
}
inline void Var::set_vartypmod(::int32_t value) {
  _internal_set_vartypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.vartypmod)
}
inline ::int32_t Var::_internal_vartypmod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.vartypmod_;
}
inline void Var::_internal_set_vartypmod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.vartypmod_ = value;
}

// uint32 varcollid = 6 [json_name = "varcollid"];
inline void Var::clear_varcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.varcollid_ = 0u;
}
inline ::uint32_t Var::varcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.varcollid)
  return _internal_varcollid();
}
inline void Var::set_varcollid(::uint32_t value) {
  _internal_set_varcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.varcollid)
}
inline ::uint32_t Var::_internal_varcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.varcollid_;
}
inline void Var::_internal_set_varcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.varcollid_ = value;
}

// repeated uint64 varnullingrels = 7 [json_name = "varnullingrels"];
inline int Var::_internal_varnullingrels_size() const {
  return _internal_varnullingrels().size();
}
inline int Var::varnullingrels_size() const {
  return _internal_varnullingrels_size();
}
inline void Var::clear_varnullingrels() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.varnullingrels_.Clear();
}
inline ::uint64_t Var::varnullingrels(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.Var.varnullingrels)
  return _internal_varnullingrels().Get(index);
}
inline void Var::set_varnullingrels(int index, ::uint64_t value) {
  _internal_mutable_varnullingrels()->Set(index, value);
  // @@protoc_insertion_point(field_set:pg_query.Var.varnullingrels)
}
inline void Var::add_varnullingrels(::uint64_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_varnullingrels()->Add(value);
  // @@protoc_insertion_point(field_add:pg_query.Var.varnullingrels)
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& Var::varnullingrels() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Var.varnullingrels)
  return _internal_varnullingrels();
}
inline ::google::protobuf::RepeatedField<::uint64_t>* Var::mutable_varnullingrels()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Var.varnullingrels)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_varnullingrels();
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& Var::_internal_varnullingrels()
    const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.varnullingrels_;
}
inline ::google::protobuf::RepeatedField<::uint64_t>* Var::_internal_mutable_varnullingrels() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.varnullingrels_;
}

// uint32 varlevelsup = 8 [json_name = "varlevelsup"];
inline void Var::clear_varlevelsup() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.varlevelsup_ = 0u;
}
inline ::uint32_t Var::varlevelsup() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.varlevelsup)
  return _internal_varlevelsup();
}
inline void Var::set_varlevelsup(::uint32_t value) {
  _internal_set_varlevelsup(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.varlevelsup)
}
inline ::uint32_t Var::_internal_varlevelsup() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.varlevelsup_;
}
inline void Var::_internal_set_varlevelsup(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.varlevelsup_ = value;
}

// int32 location = 9 [json_name = "location"];
inline void Var::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t Var::location() const {
  // @@protoc_insertion_point(field_get:pg_query.Var.location)
  return _internal_location();
}
inline void Var::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.Var.location)
}
inline ::int32_t Var::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void Var::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// Param

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool Param::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void Param::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& Param::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Param::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Param.xpr)
  return _internal_xpr();
}
inline void Param::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Param.xpr)
}
inline ::pg_query::Node* Param::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* Param::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Param.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Param::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* Param::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.Param.xpr)
  return _msg;
}
inline void Param::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Param.xpr)
}

// .pg_query.ParamKind paramkind = 2 [json_name = "paramkind"];
inline void Param::clear_paramkind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.paramkind_ = 0;
}
inline ::pg_query::ParamKind Param::paramkind() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.paramkind)
  return _internal_paramkind();
}
inline void Param::set_paramkind(::pg_query::ParamKind value) {
  _internal_set_paramkind(value);
  // @@protoc_insertion_point(field_set:pg_query.Param.paramkind)
}
inline ::pg_query::ParamKind Param::_internal_paramkind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ParamKind>(_impl_.paramkind_);
}
inline void Param::_internal_set_paramkind(::pg_query::ParamKind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.paramkind_ = value;
}

// int32 paramid = 3 [json_name = "paramid"];
inline void Param::clear_paramid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.paramid_ = 0;
}
inline ::int32_t Param::paramid() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.paramid)
  return _internal_paramid();
}
inline void Param::set_paramid(::int32_t value) {
  _internal_set_paramid(value);
  // @@protoc_insertion_point(field_set:pg_query.Param.paramid)
}
inline ::int32_t Param::_internal_paramid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.paramid_;
}
inline void Param::_internal_set_paramid(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.paramid_ = value;
}

// uint32 paramtype = 4 [json_name = "paramtype"];
inline void Param::clear_paramtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.paramtype_ = 0u;
}
inline ::uint32_t Param::paramtype() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.paramtype)
  return _internal_paramtype();
}
inline void Param::set_paramtype(::uint32_t value) {
  _internal_set_paramtype(value);
  // @@protoc_insertion_point(field_set:pg_query.Param.paramtype)
}
inline ::uint32_t Param::_internal_paramtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.paramtype_;
}
inline void Param::_internal_set_paramtype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.paramtype_ = value;
}

// int32 paramtypmod = 5 [json_name = "paramtypmod"];
inline void Param::clear_paramtypmod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.paramtypmod_ = 0;
}
inline ::int32_t Param::paramtypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.paramtypmod)
  return _internal_paramtypmod();
}
inline void Param::set_paramtypmod(::int32_t value) {
  _internal_set_paramtypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.Param.paramtypmod)
}
inline ::int32_t Param::_internal_paramtypmod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.paramtypmod_;
}
inline void Param::_internal_set_paramtypmod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.paramtypmod_ = value;
}

// uint32 paramcollid = 6 [json_name = "paramcollid"];
inline void Param::clear_paramcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.paramcollid_ = 0u;
}
inline ::uint32_t Param::paramcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.paramcollid)
  return _internal_paramcollid();
}
inline void Param::set_paramcollid(::uint32_t value) {
  _internal_set_paramcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.Param.paramcollid)
}
inline ::uint32_t Param::_internal_paramcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.paramcollid_;
}
inline void Param::_internal_set_paramcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.paramcollid_ = value;
}

// int32 location = 7 [json_name = "location"];
inline void Param::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t Param::location() const {
  // @@protoc_insertion_point(field_get:pg_query.Param.location)
  return _internal_location();
}
inline void Param::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.Param.location)
}
inline ::int32_t Param::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void Param::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// Aggref

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool Aggref::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void Aggref::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& Aggref::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Aggref::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.xpr)
  return _internal_xpr();
}
inline void Aggref::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Aggref.xpr)
}
inline ::pg_query::Node* Aggref::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* Aggref::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Aggref.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Aggref::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* Aggref::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.xpr)
  return _msg;
}
inline void Aggref::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Aggref.xpr)
}

// uint32 aggfnoid = 2 [json_name = "aggfnoid"];
inline void Aggref::clear_aggfnoid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggfnoid_ = 0u;
}
inline ::uint32_t Aggref::aggfnoid() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggfnoid)
  return _internal_aggfnoid();
}
inline void Aggref::set_aggfnoid(::uint32_t value) {
  _internal_set_aggfnoid(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggfnoid)
}
inline ::uint32_t Aggref::_internal_aggfnoid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aggfnoid_;
}
inline void Aggref::_internal_set_aggfnoid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.aggfnoid_ = value;
}

// uint32 aggtype = 3 [json_name = "aggtype"];
inline void Aggref::clear_aggtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggtype_ = 0u;
}
inline ::uint32_t Aggref::aggtype() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggtype)
  return _internal_aggtype();
}
inline void Aggref::set_aggtype(::uint32_t value) {
  _internal_set_aggtype(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggtype)
}
inline ::uint32_t Aggref::_internal_aggtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aggtype_;
}
inline void Aggref::_internal_set_aggtype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.aggtype_ = value;
}

// uint32 aggcollid = 4 [json_name = "aggcollid"];
inline void Aggref::clear_aggcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggcollid_ = 0u;
}
inline ::uint32_t Aggref::aggcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggcollid)
  return _internal_aggcollid();
}
inline void Aggref::set_aggcollid(::uint32_t value) {
  _internal_set_aggcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggcollid)
}
inline ::uint32_t Aggref::_internal_aggcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aggcollid_;
}
inline void Aggref::_internal_set_aggcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.aggcollid_ = value;
}

// uint32 inputcollid = 5 [json_name = "inputcollid"];
inline void Aggref::clear_inputcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inputcollid_ = 0u;
}
inline ::uint32_t Aggref::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.inputcollid)
  return _internal_inputcollid();
}
inline void Aggref::set_inputcollid(::uint32_t value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.inputcollid)
}
inline ::uint32_t Aggref::_internal_inputcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inputcollid_;
}
inline void Aggref::_internal_set_inputcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inputcollid_ = value;
}

// repeated .pg_query.Node aggargtypes = 6 [json_name = "aggargtypes"];
inline int Aggref::_internal_aggargtypes_size() const {
  return _internal_aggargtypes().size();
}
inline int Aggref::aggargtypes_size() const {
  return _internal_aggargtypes_size();
}
inline void Aggref::clear_aggargtypes() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggargtypes_.Clear();
}
inline ::pg_query::Node* Aggref::mutable_aggargtypes(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggargtypes)
  return _internal_mutable_aggargtypes()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Aggref::mutable_aggargtypes()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.aggargtypes)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_aggargtypes();
}
inline const ::pg_query::Node& Aggref::aggargtypes(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggargtypes)
  return _internal_aggargtypes().Get(index);
}
inline ::pg_query::Node* Aggref::add_aggargtypes() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_aggargtypes()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Aggref.aggargtypes)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Aggref::aggargtypes() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Aggref.aggargtypes)
  return _internal_aggargtypes();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Aggref::_internal_aggargtypes() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aggargtypes_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Aggref::_internal_mutable_aggargtypes() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.aggargtypes_;
}

// repeated .pg_query.Node aggdirectargs = 7 [json_name = "aggdirectargs"];
inline int Aggref::_internal_aggdirectargs_size() const {
  return _internal_aggdirectargs().size();
}
inline int Aggref::aggdirectargs_size() const {
  return _internal_aggdirectargs_size();
}
inline void Aggref::clear_aggdirectargs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggdirectargs_.Clear();
}
inline ::pg_query::Node* Aggref::mutable_aggdirectargs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggdirectargs)
  return _internal_mutable_aggdirectargs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Aggref::mutable_aggdirectargs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.aggdirectargs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_aggdirectargs();
}
inline const ::pg_query::Node& Aggref::aggdirectargs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggdirectargs)
  return _internal_aggdirectargs().Get(index);
}
inline ::pg_query::Node* Aggref::add_aggdirectargs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_aggdirectargs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Aggref.aggdirectargs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Aggref::aggdirectargs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Aggref.aggdirectargs)
  return _internal_aggdirectargs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Aggref::_internal_aggdirectargs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aggdirectargs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Aggref::_internal_mutable_aggdirectargs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.aggdirectargs_;
}

// repeated .pg_query.Node args = 8 [json_name = "args"];
inline int Aggref::_internal_args_size() const {
  return _internal_args().size();
}
inline int Aggref::args_size() const {
  return _internal_args_size();
}
inline void Aggref::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* Aggref::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Aggref::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& Aggref::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* Aggref::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Aggref.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Aggref::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Aggref.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Aggref::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Aggref::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// repeated .pg_query.Node aggorder = 9 [json_name = "aggorder"];
inline int Aggref::_internal_aggorder_size() const {
  return _internal_aggorder().size();
}
inline int Aggref::aggorder_size() const {
  return _internal_aggorder_size();
}
inline void Aggref::clear_aggorder() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggorder_.Clear();
}
inline ::pg_query::Node* Aggref::mutable_aggorder(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggorder)
  return _internal_mutable_aggorder()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Aggref::mutable_aggorder()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.aggorder)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_aggorder();
}
inline const ::pg_query::Node& Aggref::aggorder(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggorder)
  return _internal_aggorder().Get(index);
}
inline ::pg_query::Node* Aggref::add_aggorder() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_aggorder()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Aggref.aggorder)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Aggref::aggorder() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Aggref.aggorder)
  return _internal_aggorder();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Aggref::_internal_aggorder() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aggorder_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Aggref::_internal_mutable_aggorder() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.aggorder_;
}

// repeated .pg_query.Node aggdistinct = 10 [json_name = "aggdistinct"];
inline int Aggref::_internal_aggdistinct_size() const {
  return _internal_aggdistinct().size();
}
inline int Aggref::aggdistinct_size() const {
  return _internal_aggdistinct_size();
}
inline void Aggref::clear_aggdistinct() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggdistinct_.Clear();
}
inline ::pg_query::Node* Aggref::mutable_aggdistinct(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggdistinct)
  return _internal_mutable_aggdistinct()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Aggref::mutable_aggdistinct()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.aggdistinct)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_aggdistinct();
}
inline const ::pg_query::Node& Aggref::aggdistinct(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggdistinct)
  return _internal_aggdistinct().Get(index);
}
inline ::pg_query::Node* Aggref::add_aggdistinct() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_aggdistinct()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Aggref.aggdistinct)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Aggref::aggdistinct() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Aggref.aggdistinct)
  return _internal_aggdistinct();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Aggref::_internal_aggdistinct() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aggdistinct_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Aggref::_internal_mutable_aggdistinct() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.aggdistinct_;
}

// .pg_query.Node aggfilter = 11 [json_name = "aggfilter"];
inline bool Aggref::has_aggfilter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.aggfilter_ != nullptr);
  return value;
}
inline void Aggref::clear_aggfilter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.aggfilter_ != nullptr) _impl_.aggfilter_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& Aggref::_internal_aggfilter() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.aggfilter_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& Aggref::aggfilter() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggfilter)
  return _internal_aggfilter();
}
inline void Aggref::unsafe_arena_set_allocated_aggfilter(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.aggfilter_);
  }
  _impl_.aggfilter_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Aggref.aggfilter)
}
inline ::pg_query::Node* Aggref::release_aggfilter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.aggfilter_;
  _impl_.aggfilter_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* Aggref::unsafe_arena_release_aggfilter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Aggref.aggfilter)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.aggfilter_;
  _impl_.aggfilter_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Aggref::_internal_mutable_aggfilter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.aggfilter_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.aggfilter_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.aggfilter_;
}
inline ::pg_query::Node* Aggref::mutable_aggfilter() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_aggfilter();
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggfilter)
  return _msg;
}
inline void Aggref::set_allocated_aggfilter(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.aggfilter_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.aggfilter_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Aggref.aggfilter)
}

// bool aggstar = 12 [json_name = "aggstar"];
inline void Aggref::clear_aggstar() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggstar_ = false;
}
inline bool Aggref::aggstar() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggstar)
  return _internal_aggstar();
}
inline void Aggref::set_aggstar(bool value) {
  _internal_set_aggstar(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggstar)
}
inline bool Aggref::_internal_aggstar() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aggstar_;
}
inline void Aggref::_internal_set_aggstar(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.aggstar_ = value;
}

// bool aggvariadic = 13 [json_name = "aggvariadic"];
inline void Aggref::clear_aggvariadic() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggvariadic_ = false;
}
inline bool Aggref::aggvariadic() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggvariadic)
  return _internal_aggvariadic();
}
inline void Aggref::set_aggvariadic(bool value) {
  _internal_set_aggvariadic(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggvariadic)
}
inline bool Aggref::_internal_aggvariadic() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aggvariadic_;
}
inline void Aggref::_internal_set_aggvariadic(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.aggvariadic_ = value;
}

// string aggkind = 14 [json_name = "aggkind"];
inline void Aggref::clear_aggkind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggkind_.ClearToEmpty();
}
inline const std::string& Aggref::aggkind() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggkind)
  return _internal_aggkind();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Aggref::set_aggkind(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.aggkind_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggkind)
}
inline std::string* Aggref::mutable_aggkind() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_aggkind();
  // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggkind)
  return _s;
}
inline const std::string& Aggref::_internal_aggkind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aggkind_.Get();
}
inline void Aggref::_internal_set_aggkind(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.aggkind_.Set(value, GetArena());
}
inline std::string* Aggref::_internal_mutable_aggkind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.aggkind_.Mutable( GetArena());
}
inline std::string* Aggref::release_aggkind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Aggref.aggkind)
  return _impl_.aggkind_.Release();
}
inline void Aggref::set_allocated_aggkind(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggkind_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.aggkind_.IsDefault()) {
          _impl_.aggkind_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.Aggref.aggkind)
}

// uint32 agglevelsup = 15 [json_name = "agglevelsup"];
inline void Aggref::clear_agglevelsup() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.agglevelsup_ = 0u;
}
inline ::uint32_t Aggref::agglevelsup() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.agglevelsup)
  return _internal_agglevelsup();
}
inline void Aggref::set_agglevelsup(::uint32_t value) {
  _internal_set_agglevelsup(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.agglevelsup)
}
inline ::uint32_t Aggref::_internal_agglevelsup() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.agglevelsup_;
}
inline void Aggref::_internal_set_agglevelsup(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.agglevelsup_ = value;
}

// .pg_query.AggSplit aggsplit = 16 [json_name = "aggsplit"];
inline void Aggref::clear_aggsplit() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggsplit_ = 0;
}
inline ::pg_query::AggSplit Aggref::aggsplit() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggsplit)
  return _internal_aggsplit();
}
inline void Aggref::set_aggsplit(::pg_query::AggSplit value) {
  _internal_set_aggsplit(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggsplit)
}
inline ::pg_query::AggSplit Aggref::_internal_aggsplit() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::AggSplit>(_impl_.aggsplit_);
}
inline void Aggref::_internal_set_aggsplit(::pg_query::AggSplit value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.aggsplit_ = value;
}

// int32 aggno = 17 [json_name = "aggno"];
inline void Aggref::clear_aggno() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggno_ = 0;
}
inline ::int32_t Aggref::aggno() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggno)
  return _internal_aggno();
}
inline void Aggref::set_aggno(::int32_t value) {
  _internal_set_aggno(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggno)
}
inline ::int32_t Aggref::_internal_aggno() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aggno_;
}
inline void Aggref::_internal_set_aggno(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.aggno_ = value;
}

// int32 aggtransno = 18 [json_name = "aggtransno"];
inline void Aggref::clear_aggtransno() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aggtransno_ = 0;
}
inline ::int32_t Aggref::aggtransno() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.aggtransno)
  return _internal_aggtransno();
}
inline void Aggref::set_aggtransno(::int32_t value) {
  _internal_set_aggtransno(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.aggtransno)
}
inline ::int32_t Aggref::_internal_aggtransno() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aggtransno_;
}
inline void Aggref::_internal_set_aggtransno(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.aggtransno_ = value;
}

// int32 location = 19 [json_name = "location"];
inline void Aggref::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t Aggref::location() const {
  // @@protoc_insertion_point(field_get:pg_query.Aggref.location)
  return _internal_location();
}
inline void Aggref::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.Aggref.location)
}
inline ::int32_t Aggref::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void Aggref::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// GroupingFunc

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool GroupingFunc::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void GroupingFunc::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& GroupingFunc::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& GroupingFunc::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.xpr)
  return _internal_xpr();
}
inline void GroupingFunc::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.GroupingFunc.xpr)
}
inline ::pg_query::Node* GroupingFunc::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* GroupingFunc::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.GroupingFunc.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* GroupingFunc::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* GroupingFunc::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.GroupingFunc.xpr)
  return _msg;
}
inline void GroupingFunc::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_args().size();
}
inline int GroupingFunc::args_size() const {
  return _internal_args_size();
}
inline void GroupingFunc::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* GroupingFunc::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.GroupingFunc.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* GroupingFunc::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GroupingFunc.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& GroupingFunc::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* GroupingFunc::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.GroupingFunc.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& GroupingFunc::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.GroupingFunc.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
GroupingFunc::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
GroupingFunc::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// repeated .pg_query.Node refs = 3 [json_name = "refs"];
inline int GroupingFunc::_internal_refs_size() const {
  return _internal_refs().size();
}
inline int GroupingFunc::refs_size() const {
  return _internal_refs_size();
}
inline void GroupingFunc::clear_refs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.refs_.Clear();
}
inline ::pg_query::Node* GroupingFunc::mutable_refs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.GroupingFunc.refs)
  return _internal_mutable_refs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* GroupingFunc::mutable_refs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GroupingFunc.refs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_refs();
}
inline const ::pg_query::Node& GroupingFunc::refs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.refs)
  return _internal_refs().Get(index);
}
inline ::pg_query::Node* GroupingFunc::add_refs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_refs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.GroupingFunc.refs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& GroupingFunc::refs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.GroupingFunc.refs)
  return _internal_refs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
GroupingFunc::_internal_refs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.refs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
GroupingFunc::_internal_mutable_refs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.refs_;
}

// uint32 agglevelsup = 4 [json_name = "agglevelsup"];
inline void GroupingFunc::clear_agglevelsup() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.agglevelsup_ = 0u;
}
inline ::uint32_t GroupingFunc::agglevelsup() const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.agglevelsup)
  return _internal_agglevelsup();
}
inline void GroupingFunc::set_agglevelsup(::uint32_t value) {
  _internal_set_agglevelsup(value);
  // @@protoc_insertion_point(field_set:pg_query.GroupingFunc.agglevelsup)
}
inline ::uint32_t GroupingFunc::_internal_agglevelsup() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.agglevelsup_;
}
inline void GroupingFunc::_internal_set_agglevelsup(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.agglevelsup_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void GroupingFunc::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t GroupingFunc::location() const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.location)
  return _internal_location();
}
inline void GroupingFunc::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.GroupingFunc.location)
}
inline ::int32_t GroupingFunc::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void GroupingFunc::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// WindowFunc

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool WindowFunc::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void WindowFunc::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& WindowFunc::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& WindowFunc::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.xpr)
  return _internal_xpr();
}
inline void WindowFunc::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowFunc.xpr)
}
inline ::pg_query::Node* WindowFunc::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* WindowFunc::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WindowFunc.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WindowFunc::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* WindowFunc::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.WindowFunc.xpr)
  return _msg;
}
inline void WindowFunc::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowFunc.xpr)
}

// uint32 winfnoid = 2 [json_name = "winfnoid"];
inline void WindowFunc::clear_winfnoid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.winfnoid_ = 0u;
}
inline ::uint32_t WindowFunc::winfnoid() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.winfnoid)
  return _internal_winfnoid();
}
inline void WindowFunc::set_winfnoid(::uint32_t value) {
  _internal_set_winfnoid(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.winfnoid)
}
inline ::uint32_t WindowFunc::_internal_winfnoid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.winfnoid_;
}
inline void WindowFunc::_internal_set_winfnoid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.winfnoid_ = value;
}

// uint32 wintype = 3 [json_name = "wintype"];
inline void WindowFunc::clear_wintype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.wintype_ = 0u;
}
inline ::uint32_t WindowFunc::wintype() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.wintype)
  return _internal_wintype();
}
inline void WindowFunc::set_wintype(::uint32_t value) {
  _internal_set_wintype(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.wintype)
}
inline ::uint32_t WindowFunc::_internal_wintype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.wintype_;
}
inline void WindowFunc::_internal_set_wintype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.wintype_ = value;
}

// uint32 wincollid = 4 [json_name = "wincollid"];
inline void WindowFunc::clear_wincollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.wincollid_ = 0u;
}
inline ::uint32_t WindowFunc::wincollid() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.wincollid)
  return _internal_wincollid();
}
inline void WindowFunc::set_wincollid(::uint32_t value) {
  _internal_set_wincollid(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.wincollid)
}
inline ::uint32_t WindowFunc::_internal_wincollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.wincollid_;
}
inline void WindowFunc::_internal_set_wincollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.wincollid_ = value;
}

// uint32 inputcollid = 5 [json_name = "inputcollid"];
inline void WindowFunc::clear_inputcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inputcollid_ = 0u;
}
inline ::uint32_t WindowFunc::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.inputcollid)
  return _internal_inputcollid();
}
inline void WindowFunc::set_inputcollid(::uint32_t value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.inputcollid)
}
inline ::uint32_t WindowFunc::_internal_inputcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inputcollid_;
}
inline void WindowFunc::_internal_set_inputcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inputcollid_ = value;
}

// repeated .pg_query.Node args = 6 [json_name = "args"];
inline int WindowFunc::_internal_args_size() const {
  return _internal_args().size();
}
inline int WindowFunc::args_size() const {
  return _internal_args_size();
}
inline void WindowFunc::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* WindowFunc::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowFunc.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* WindowFunc::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WindowFunc.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& WindowFunc::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* WindowFunc::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.WindowFunc.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& WindowFunc::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.WindowFunc.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
WindowFunc::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
WindowFunc::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// .pg_query.Node aggfilter = 7 [json_name = "aggfilter"];
inline bool WindowFunc::has_aggfilter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.aggfilter_ != nullptr);
  return value;
}
inline void WindowFunc::clear_aggfilter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.aggfilter_ != nullptr) _impl_.aggfilter_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& WindowFunc::_internal_aggfilter() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.aggfilter_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& WindowFunc::aggfilter() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.aggfilter)
  return _internal_aggfilter();
}
inline void WindowFunc::unsafe_arena_set_allocated_aggfilter(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.aggfilter_);
  }
  _impl_.aggfilter_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowFunc.aggfilter)
}
inline ::pg_query::Node* WindowFunc::release_aggfilter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.aggfilter_;
  _impl_.aggfilter_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* WindowFunc::unsafe_arena_release_aggfilter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WindowFunc.aggfilter)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.aggfilter_;
  _impl_.aggfilter_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WindowFunc::_internal_mutable_aggfilter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.aggfilter_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.aggfilter_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.aggfilter_;
}
inline ::pg_query::Node* WindowFunc::mutable_aggfilter() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_aggfilter();
  // @@protoc_insertion_point(field_mutable:pg_query.WindowFunc.aggfilter)
  return _msg;
}
inline void WindowFunc::set_allocated_aggfilter(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.aggfilter_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.aggfilter_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowFunc.aggfilter)
}

// uint32 winref = 8 [json_name = "winref"];
inline void WindowFunc::clear_winref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.winref_ = 0u;
}
inline ::uint32_t WindowFunc::winref() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.winref)
  return _internal_winref();
}
inline void WindowFunc::set_winref(::uint32_t value) {
  _internal_set_winref(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.winref)
}
inline ::uint32_t WindowFunc::_internal_winref() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.winref_;
}
inline void WindowFunc::_internal_set_winref(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.winref_ = value;
}

// bool winstar = 9 [json_name = "winstar"];
inline void WindowFunc::clear_winstar() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.winstar_ = false;
}
inline bool WindowFunc::winstar() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.winstar)
  return _internal_winstar();
}
inline void WindowFunc::set_winstar(bool value) {
  _internal_set_winstar(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.winstar)
}
inline bool WindowFunc::_internal_winstar() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.winstar_;
}
inline void WindowFunc::_internal_set_winstar(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.winstar_ = value;
}

// bool winagg = 10 [json_name = "winagg"];
inline void WindowFunc::clear_winagg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.winagg_ = false;
}
inline bool WindowFunc::winagg() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.winagg)
  return _internal_winagg();
}
inline void WindowFunc::set_winagg(bool value) {
  _internal_set_winagg(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.winagg)
}
inline bool WindowFunc::_internal_winagg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.winagg_;
}
inline void WindowFunc::_internal_set_winagg(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.winagg_ = value;
}

// int32 location = 11 [json_name = "location"];
inline void WindowFunc::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t WindowFunc::location() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowFunc.location)
  return _internal_location();
}
inline void WindowFunc::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowFunc.location)
}
inline ::int32_t WindowFunc::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void WindowFunc::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// SubscriptingRef

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool SubscriptingRef::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void SubscriptingRef::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& SubscriptingRef::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubscriptingRef::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.xpr)
  return _internal_xpr();
}
inline void SubscriptingRef::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubscriptingRef.xpr)
}
inline ::pg_query::Node* SubscriptingRef::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SubscriptingRef::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SubscriptingRef.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubscriptingRef::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* SubscriptingRef::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.SubscriptingRef.xpr)
  return _msg;
}
inline void SubscriptingRef::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubscriptingRef.xpr)
}

// uint32 refcontainertype = 2 [json_name = "refcontainertype"];
inline void SubscriptingRef::clear_refcontainertype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.refcontainertype_ = 0u;
}
inline ::uint32_t SubscriptingRef::refcontainertype() const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refcontainertype)
  return _internal_refcontainertype();
}
inline void SubscriptingRef::set_refcontainertype(::uint32_t value) {
  _internal_set_refcontainertype(value);
  // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.refcontainertype)
}
inline ::uint32_t SubscriptingRef::_internal_refcontainertype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.refcontainertype_;
}
inline void SubscriptingRef::_internal_set_refcontainertype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.refcontainertype_ = value;
}

// uint32 refelemtype = 3 [json_name = "refelemtype"];
inline void SubscriptingRef::clear_refelemtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.refelemtype_ = 0u;
}
inline ::uint32_t SubscriptingRef::refelemtype() const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refelemtype)
  return _internal_refelemtype();
}
inline void SubscriptingRef::set_refelemtype(::uint32_t value) {
  _internal_set_refelemtype(value);
  // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.refelemtype)
}
inline ::uint32_t SubscriptingRef::_internal_refelemtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.refelemtype_;
}
inline void SubscriptingRef::_internal_set_refelemtype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.refelemtype_ = value;
}

// uint32 refrestype = 4 [json_name = "refrestype"];
inline void SubscriptingRef::clear_refrestype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.refrestype_ = 0u;
}
inline ::uint32_t SubscriptingRef::refrestype() const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refrestype)
  return _internal_refrestype();
}
inline void SubscriptingRef::set_refrestype(::uint32_t value) {
  _internal_set_refrestype(value);
  // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.refrestype)
}
inline ::uint32_t SubscriptingRef::_internal_refrestype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.refrestype_;
}
inline void SubscriptingRef::_internal_set_refrestype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.refrestype_ = value;
}

// int32 reftypmod = 5 [json_name = "reftypmod"];
inline void SubscriptingRef::clear_reftypmod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.reftypmod_ = 0;
}
inline ::int32_t SubscriptingRef::reftypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.reftypmod)
  return _internal_reftypmod();
}
inline void SubscriptingRef::set_reftypmod(::int32_t value) {
  _internal_set_reftypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.reftypmod)
}
inline ::int32_t SubscriptingRef::_internal_reftypmod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.reftypmod_;
}
inline void SubscriptingRef::_internal_set_reftypmod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.reftypmod_ = value;
}

// uint32 refcollid = 6 [json_name = "refcollid"];
inline void SubscriptingRef::clear_refcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.refcollid_ = 0u;
}
inline ::uint32_t SubscriptingRef::refcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refcollid)
  return _internal_refcollid();
}
inline void SubscriptingRef::set_refcollid(::uint32_t value) {
  _internal_set_refcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.refcollid)
}
inline ::uint32_t SubscriptingRef::_internal_refcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.refcollid_;
}
inline void SubscriptingRef::_internal_set_refcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.refcollid_ = value;
}

// repeated .pg_query.Node refupperindexpr = 7 [json_name = "refupperindexpr"];
inline int SubscriptingRef::_internal_refupperindexpr_size() const {
  return _internal_refupperindexpr().size();
}
inline int SubscriptingRef::refupperindexpr_size() const {
  return _internal_refupperindexpr_size();
}
inline void SubscriptingRef::clear_refupperindexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.refupperindexpr_.Clear();
}
inline ::pg_query::Node* SubscriptingRef::mutable_refupperindexpr(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SubscriptingRef.refupperindexpr)
  return _internal_mutable_refupperindexpr()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SubscriptingRef::mutable_refupperindexpr()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubscriptingRef.refupperindexpr)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_refupperindexpr();
}
inline const ::pg_query::Node& SubscriptingRef::refupperindexpr(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refupperindexpr)
  return _internal_refupperindexpr().Get(index);
}
inline ::pg_query::Node* SubscriptingRef::add_refupperindexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_refupperindexpr()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SubscriptingRef.refupperindexpr)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SubscriptingRef::refupperindexpr() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SubscriptingRef.refupperindexpr)
  return _internal_refupperindexpr();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SubscriptingRef::_internal_refupperindexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.refupperindexpr_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SubscriptingRef::_internal_mutable_refupperindexpr() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.refupperindexpr_;
}

// repeated .pg_query.Node reflowerindexpr = 8 [json_name = "reflowerindexpr"];
inline int SubscriptingRef::_internal_reflowerindexpr_size() const {
  return _internal_reflowerindexpr().size();
}
inline int SubscriptingRef::reflowerindexpr_size() const {
  return _internal_reflowerindexpr_size();
}
inline void SubscriptingRef::clear_reflowerindexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.reflowerindexpr_.Clear();
}
inline ::pg_query::Node* SubscriptingRef::mutable_reflowerindexpr(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SubscriptingRef.reflowerindexpr)
  return _internal_mutable_reflowerindexpr()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SubscriptingRef::mutable_reflowerindexpr()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubscriptingRef.reflowerindexpr)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_reflowerindexpr();
}
inline const ::pg_query::Node& SubscriptingRef::reflowerindexpr(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.reflowerindexpr)
  return _internal_reflowerindexpr().Get(index);
}
inline ::pg_query::Node* SubscriptingRef::add_reflowerindexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_reflowerindexpr()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SubscriptingRef.reflowerindexpr)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SubscriptingRef::reflowerindexpr() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SubscriptingRef.reflowerindexpr)
  return _internal_reflowerindexpr();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SubscriptingRef::_internal_reflowerindexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.reflowerindexpr_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SubscriptingRef::_internal_mutable_reflowerindexpr() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.reflowerindexpr_;
}

// .pg_query.Node refexpr = 9 [json_name = "refexpr"];
inline bool SubscriptingRef::has_refexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.refexpr_ != nullptr);
  return value;
}
inline void SubscriptingRef::clear_refexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.refexpr_ != nullptr) _impl_.refexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& SubscriptingRef::_internal_refexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.refexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubscriptingRef::refexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refexpr)
  return _internal_refexpr();
}
inline void SubscriptingRef::unsafe_arena_set_allocated_refexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.refexpr_);
  }
  _impl_.refexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubscriptingRef.refexpr)
}
inline ::pg_query::Node* SubscriptingRef::release_refexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.refexpr_;
  _impl_.refexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SubscriptingRef::unsafe_arena_release_refexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SubscriptingRef.refexpr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.refexpr_;
  _impl_.refexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubscriptingRef::_internal_mutable_refexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.refexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.refexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.refexpr_;
}
inline ::pg_query::Node* SubscriptingRef::mutable_refexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_refexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.SubscriptingRef.refexpr)
  return _msg;
}
inline void SubscriptingRef::set_allocated_refexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.refexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.refexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubscriptingRef.refexpr)
}

// .pg_query.Node refassgnexpr = 10 [json_name = "refassgnexpr"];
inline bool SubscriptingRef::has_refassgnexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.refassgnexpr_ != nullptr);
  return value;
}
inline void SubscriptingRef::clear_refassgnexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.refassgnexpr_ != nullptr) _impl_.refassgnexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& SubscriptingRef::_internal_refassgnexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.refassgnexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubscriptingRef::refassgnexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refassgnexpr)
  return _internal_refassgnexpr();
}
inline void SubscriptingRef::unsafe_arena_set_allocated_refassgnexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.refassgnexpr_);
  }
  _impl_.refassgnexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubscriptingRef.refassgnexpr)
}
inline ::pg_query::Node* SubscriptingRef::release_refassgnexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.refassgnexpr_;
  _impl_.refassgnexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SubscriptingRef::unsafe_arena_release_refassgnexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SubscriptingRef.refassgnexpr)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.refassgnexpr_;
  _impl_.refassgnexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubscriptingRef::_internal_mutable_refassgnexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.refassgnexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.refassgnexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.refassgnexpr_;
}
inline ::pg_query::Node* SubscriptingRef::mutable_refassgnexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_refassgnexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.SubscriptingRef.refassgnexpr)
  return _msg;
}
inline void SubscriptingRef::set_allocated_refassgnexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.refassgnexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.refassgnexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubscriptingRef.refassgnexpr)
}

// -------------------------------------------------------------------

// FuncExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool FuncExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void FuncExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& FuncExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FuncExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.xpr)
  return _internal_xpr();
}
inline void FuncExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FuncExpr.xpr)
}
inline ::pg_query::Node* FuncExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* FuncExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.FuncExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FuncExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* FuncExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.FuncExpr.xpr)
  return _msg;
}
inline void FuncExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.FuncExpr.xpr)
}

// uint32 funcid = 2 [json_name = "funcid"];
inline void FuncExpr::clear_funcid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funcid_ = 0u;
}
inline ::uint32_t FuncExpr::funcid() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcid)
  return _internal_funcid();
}
inline void FuncExpr::set_funcid(::uint32_t value) {
  _internal_set_funcid(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcid)
}
inline ::uint32_t FuncExpr::_internal_funcid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funcid_;
}
inline void FuncExpr::_internal_set_funcid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.funcid_ = value;
}

// uint32 funcresulttype = 3 [json_name = "funcresulttype"];
inline void FuncExpr::clear_funcresulttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funcresulttype_ = 0u;
}
inline ::uint32_t FuncExpr::funcresulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcresulttype)
  return _internal_funcresulttype();
}
inline void FuncExpr::set_funcresulttype(::uint32_t value) {
  _internal_set_funcresulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcresulttype)
}
inline ::uint32_t FuncExpr::_internal_funcresulttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funcresulttype_;
}
inline void FuncExpr::_internal_set_funcresulttype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.funcresulttype_ = value;
}

// bool funcretset = 4 [json_name = "funcretset"];
inline void FuncExpr::clear_funcretset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funcretset_ = false;
}
inline bool FuncExpr::funcretset() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcretset)
  return _internal_funcretset();
}
inline void FuncExpr::set_funcretset(bool value) {
  _internal_set_funcretset(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcretset)
}
inline bool FuncExpr::_internal_funcretset() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funcretset_;
}
inline void FuncExpr::_internal_set_funcretset(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.funcretset_ = value;
}

// bool funcvariadic = 5 [json_name = "funcvariadic"];
inline void FuncExpr::clear_funcvariadic() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funcvariadic_ = false;
}
inline bool FuncExpr::funcvariadic() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcvariadic)
  return _internal_funcvariadic();
}
inline void FuncExpr::set_funcvariadic(bool value) {
  _internal_set_funcvariadic(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcvariadic)
}
inline bool FuncExpr::_internal_funcvariadic() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funcvariadic_;
}
inline void FuncExpr::_internal_set_funcvariadic(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.funcvariadic_ = value;
}

// .pg_query.CoercionForm funcformat = 6 [json_name = "funcformat"];
inline void FuncExpr::clear_funcformat() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funcformat_ = 0;
}
inline ::pg_query::CoercionForm FuncExpr::funcformat() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcformat)
  return _internal_funcformat();
}
inline void FuncExpr::set_funcformat(::pg_query::CoercionForm value) {
  _internal_set_funcformat(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcformat)
}
inline ::pg_query::CoercionForm FuncExpr::_internal_funcformat() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CoercionForm>(_impl_.funcformat_);
}
inline void FuncExpr::_internal_set_funcformat(::pg_query::CoercionForm value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.funcformat_ = value;
}

// uint32 funccollid = 7 [json_name = "funccollid"];
inline void FuncExpr::clear_funccollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funccollid_ = 0u;
}
inline ::uint32_t FuncExpr::funccollid() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funccollid)
  return _internal_funccollid();
}
inline void FuncExpr::set_funccollid(::uint32_t value) {
  _internal_set_funccollid(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funccollid)
}
inline ::uint32_t FuncExpr::_internal_funccollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funccollid_;
}
inline void FuncExpr::_internal_set_funccollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.funccollid_ = value;
}

// uint32 inputcollid = 8 [json_name = "inputcollid"];
inline void FuncExpr::clear_inputcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inputcollid_ = 0u;
}
inline ::uint32_t FuncExpr::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.inputcollid)
  return _internal_inputcollid();
}
inline void FuncExpr::set_inputcollid(::uint32_t value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.inputcollid)
}
inline ::uint32_t FuncExpr::_internal_inputcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inputcollid_;
}
inline void FuncExpr::_internal_set_inputcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inputcollid_ = value;
}

// repeated .pg_query.Node args = 9 [json_name = "args"];
inline int FuncExpr::_internal_args_size() const {
  return _internal_args().size();
}
inline int FuncExpr::args_size() const {
  return _internal_args_size();
}
inline void FuncExpr::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* FuncExpr::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.FuncExpr.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* FuncExpr::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FuncExpr.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& FuncExpr::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* FuncExpr::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.FuncExpr.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& FuncExpr::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.FuncExpr.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
FuncExpr::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
FuncExpr::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// int32 location = 10 [json_name = "location"];
inline void FuncExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t FuncExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncExpr.location)
  return _internal_location();
}
inline void FuncExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncExpr.location)
}
inline ::int32_t FuncExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void FuncExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// NamedArgExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool NamedArgExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void NamedArgExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& NamedArgExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& NamedArgExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.xpr)
  return _internal_xpr();
}
inline void NamedArgExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NamedArgExpr.xpr)
}
inline ::pg_query::Node* NamedArgExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* NamedArgExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.NamedArgExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* NamedArgExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* NamedArgExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.NamedArgExpr.xpr)
  return _msg;
}
inline void NamedArgExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.NamedArgExpr.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool NamedArgExpr::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void NamedArgExpr::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& NamedArgExpr::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& NamedArgExpr::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.arg)
  return _internal_arg();
}
inline void NamedArgExpr::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NamedArgExpr.arg)
}
inline ::pg_query::Node* NamedArgExpr::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* NamedArgExpr::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.NamedArgExpr.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* NamedArgExpr::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* NamedArgExpr::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.NamedArgExpr.arg)
  return _msg;
}
inline void NamedArgExpr::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.NamedArgExpr.arg)
}

// string name = 3 [json_name = "name"];
inline void NamedArgExpr::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& NamedArgExpr::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void NamedArgExpr::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.NamedArgExpr.name)
}
inline std::string* NamedArgExpr::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.NamedArgExpr.name)
  return _s;
}
inline const std::string& NamedArgExpr::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void NamedArgExpr::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* NamedArgExpr::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* NamedArgExpr::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.NamedArgExpr.name)
  return _impl_.name_.Release();
}
inline void NamedArgExpr::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.NamedArgExpr.name)
}

// int32 argnumber = 4 [json_name = "argnumber"];
inline void NamedArgExpr::clear_argnumber() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.argnumber_ = 0;
}
inline ::int32_t NamedArgExpr::argnumber() const {
  // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.argnumber)
  return _internal_argnumber();
}
inline void NamedArgExpr::set_argnumber(::int32_t value) {
  _internal_set_argnumber(value);
  // @@protoc_insertion_point(field_set:pg_query.NamedArgExpr.argnumber)
}
inline ::int32_t NamedArgExpr::_internal_argnumber() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.argnumber_;
}
inline void NamedArgExpr::_internal_set_argnumber(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.argnumber_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void NamedArgExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t NamedArgExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.location)
  return _internal_location();
}
inline void NamedArgExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.NamedArgExpr.location)
}
inline ::int32_t NamedArgExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void NamedArgExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// OpExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool OpExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void OpExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& OpExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& OpExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.xpr)
  return _internal_xpr();
}
inline void OpExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OpExpr.xpr)
}
inline ::pg_query::Node* OpExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* OpExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.OpExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* OpExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* OpExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.OpExpr.xpr)
  return _msg;
}
inline void OpExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.OpExpr.xpr)
}

// uint32 opno = 2 [json_name = "opno"];
inline void OpExpr::clear_opno() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opno_ = 0u;
}
inline ::uint32_t OpExpr::opno() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.opno)
  return _internal_opno();
}
inline void OpExpr::set_opno(::uint32_t value) {
  _internal_set_opno(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.opno)
}
inline ::uint32_t OpExpr::_internal_opno() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opno_;
}
inline void OpExpr::_internal_set_opno(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opno_ = value;
}

// uint32 opresulttype = 3 [json_name = "opresulttype"];
inline void OpExpr::clear_opresulttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opresulttype_ = 0u;
}
inline ::uint32_t OpExpr::opresulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.opresulttype)
  return _internal_opresulttype();
}
inline void OpExpr::set_opresulttype(::uint32_t value) {
  _internal_set_opresulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.opresulttype)
}
inline ::uint32_t OpExpr::_internal_opresulttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opresulttype_;
}
inline void OpExpr::_internal_set_opresulttype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opresulttype_ = value;
}

// bool opretset = 4 [json_name = "opretset"];
inline void OpExpr::clear_opretset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opretset_ = false;
}
inline bool OpExpr::opretset() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.opretset)
  return _internal_opretset();
}
inline void OpExpr::set_opretset(bool value) {
  _internal_set_opretset(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.opretset)
}
inline bool OpExpr::_internal_opretset() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opretset_;
}
inline void OpExpr::_internal_set_opretset(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opretset_ = value;
}

// uint32 opcollid = 5 [json_name = "opcollid"];
inline void OpExpr::clear_opcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opcollid_ = 0u;
}
inline ::uint32_t OpExpr::opcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.opcollid)
  return _internal_opcollid();
}
inline void OpExpr::set_opcollid(::uint32_t value) {
  _internal_set_opcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.opcollid)
}
inline ::uint32_t OpExpr::_internal_opcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opcollid_;
}
inline void OpExpr::_internal_set_opcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opcollid_ = value;
}

// uint32 inputcollid = 6 [json_name = "inputcollid"];
inline void OpExpr::clear_inputcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inputcollid_ = 0u;
}
inline ::uint32_t OpExpr::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.inputcollid)
  return _internal_inputcollid();
}
inline void OpExpr::set_inputcollid(::uint32_t value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.inputcollid)
}
inline ::uint32_t OpExpr::_internal_inputcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inputcollid_;
}
inline void OpExpr::_internal_set_inputcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inputcollid_ = value;
}

// repeated .pg_query.Node args = 7 [json_name = "args"];
inline int OpExpr::_internal_args_size() const {
  return _internal_args().size();
}
inline int OpExpr::args_size() const {
  return _internal_args_size();
}
inline void OpExpr::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* OpExpr::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.OpExpr.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* OpExpr::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.OpExpr.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& OpExpr::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* OpExpr::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.OpExpr.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& OpExpr::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.OpExpr.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
OpExpr::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
OpExpr::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// int32 location = 8 [json_name = "location"];
inline void OpExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t OpExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.OpExpr.location)
  return _internal_location();
}
inline void OpExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.OpExpr.location)
}
inline ::int32_t OpExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void OpExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// DistinctExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool DistinctExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void DistinctExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& DistinctExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& DistinctExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.xpr)
  return _internal_xpr();
}
inline void DistinctExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DistinctExpr.xpr)
}
inline ::pg_query::Node* DistinctExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* DistinctExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DistinctExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* DistinctExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* DistinctExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.DistinctExpr.xpr)
  return _msg;
}
inline void DistinctExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.DistinctExpr.xpr)
}

// uint32 opno = 2 [json_name = "opno"];
inline void DistinctExpr::clear_opno() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opno_ = 0u;
}
inline ::uint32_t DistinctExpr::opno() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opno)
  return _internal_opno();
}
inline void DistinctExpr::set_opno(::uint32_t value) {
  _internal_set_opno(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opno)
}
inline ::uint32_t DistinctExpr::_internal_opno() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opno_;
}
inline void DistinctExpr::_internal_set_opno(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opno_ = value;
}

// uint32 opresulttype = 3 [json_name = "opresulttype"];
inline void DistinctExpr::clear_opresulttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opresulttype_ = 0u;
}
inline ::uint32_t DistinctExpr::opresulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opresulttype)
  return _internal_opresulttype();
}
inline void DistinctExpr::set_opresulttype(::uint32_t value) {
  _internal_set_opresulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opresulttype)
}
inline ::uint32_t DistinctExpr::_internal_opresulttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opresulttype_;
}
inline void DistinctExpr::_internal_set_opresulttype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opresulttype_ = value;
}

// bool opretset = 4 [json_name = "opretset"];
inline void DistinctExpr::clear_opretset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opretset_ = false;
}
inline bool DistinctExpr::opretset() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opretset)
  return _internal_opretset();
}
inline void DistinctExpr::set_opretset(bool value) {
  _internal_set_opretset(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opretset)
}
inline bool DistinctExpr::_internal_opretset() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opretset_;
}
inline void DistinctExpr::_internal_set_opretset(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opretset_ = value;
}

// uint32 opcollid = 5 [json_name = "opcollid"];
inline void DistinctExpr::clear_opcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opcollid_ = 0u;
}
inline ::uint32_t DistinctExpr::opcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opcollid)
  return _internal_opcollid();
}
inline void DistinctExpr::set_opcollid(::uint32_t value) {
  _internal_set_opcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opcollid)
}
inline ::uint32_t DistinctExpr::_internal_opcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opcollid_;
}
inline void DistinctExpr::_internal_set_opcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opcollid_ = value;
}

// uint32 inputcollid = 6 [json_name = "inputcollid"];
inline void DistinctExpr::clear_inputcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inputcollid_ = 0u;
}
inline ::uint32_t DistinctExpr::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.inputcollid)
  return _internal_inputcollid();
}
inline void DistinctExpr::set_inputcollid(::uint32_t value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.inputcollid)
}
inline ::uint32_t DistinctExpr::_internal_inputcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inputcollid_;
}
inline void DistinctExpr::_internal_set_inputcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inputcollid_ = value;
}

// repeated .pg_query.Node args = 7 [json_name = "args"];
inline int DistinctExpr::_internal_args_size() const {
  return _internal_args().size();
}
inline int DistinctExpr::args_size() const {
  return _internal_args_size();
}
inline void DistinctExpr::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* DistinctExpr::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.DistinctExpr.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* DistinctExpr::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DistinctExpr.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& DistinctExpr::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* DistinctExpr::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.DistinctExpr.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& DistinctExpr::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.DistinctExpr.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
DistinctExpr::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
DistinctExpr::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// int32 location = 8 [json_name = "location"];
inline void DistinctExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t DistinctExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.location)
  return _internal_location();
}
inline void DistinctExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.location)
}
inline ::int32_t DistinctExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void DistinctExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// NullIfExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool NullIfExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void NullIfExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& NullIfExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& NullIfExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.xpr)
  return _internal_xpr();
}
inline void NullIfExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NullIfExpr.xpr)
}
inline ::pg_query::Node* NullIfExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* NullIfExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.NullIfExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* NullIfExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* NullIfExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.NullIfExpr.xpr)
  return _msg;
}
inline void NullIfExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.NullIfExpr.xpr)
}

// uint32 opno = 2 [json_name = "opno"];
inline void NullIfExpr::clear_opno() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opno_ = 0u;
}
inline ::uint32_t NullIfExpr::opno() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opno)
  return _internal_opno();
}
inline void NullIfExpr::set_opno(::uint32_t value) {
  _internal_set_opno(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opno)
}
inline ::uint32_t NullIfExpr::_internal_opno() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opno_;
}
inline void NullIfExpr::_internal_set_opno(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opno_ = value;
}

// uint32 opresulttype = 3 [json_name = "opresulttype"];
inline void NullIfExpr::clear_opresulttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opresulttype_ = 0u;
}
inline ::uint32_t NullIfExpr::opresulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opresulttype)
  return _internal_opresulttype();
}
inline void NullIfExpr::set_opresulttype(::uint32_t value) {
  _internal_set_opresulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opresulttype)
}
inline ::uint32_t NullIfExpr::_internal_opresulttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opresulttype_;
}
inline void NullIfExpr::_internal_set_opresulttype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opresulttype_ = value;
}

// bool opretset = 4 [json_name = "opretset"];
inline void NullIfExpr::clear_opretset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opretset_ = false;
}
inline bool NullIfExpr::opretset() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opretset)
  return _internal_opretset();
}
inline void NullIfExpr::set_opretset(bool value) {
  _internal_set_opretset(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opretset)
}
inline bool NullIfExpr::_internal_opretset() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opretset_;
}
inline void NullIfExpr::_internal_set_opretset(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opretset_ = value;
}

// uint32 opcollid = 5 [json_name = "opcollid"];
inline void NullIfExpr::clear_opcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opcollid_ = 0u;
}
inline ::uint32_t NullIfExpr::opcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opcollid)
  return _internal_opcollid();
}
inline void NullIfExpr::set_opcollid(::uint32_t value) {
  _internal_set_opcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opcollid)
}
inline ::uint32_t NullIfExpr::_internal_opcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opcollid_;
}
inline void NullIfExpr::_internal_set_opcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opcollid_ = value;
}

// uint32 inputcollid = 6 [json_name = "inputcollid"];
inline void NullIfExpr::clear_inputcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inputcollid_ = 0u;
}
inline ::uint32_t NullIfExpr::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.inputcollid)
  return _internal_inputcollid();
}
inline void NullIfExpr::set_inputcollid(::uint32_t value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.inputcollid)
}
inline ::uint32_t NullIfExpr::_internal_inputcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inputcollid_;
}
inline void NullIfExpr::_internal_set_inputcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inputcollid_ = value;
}

// repeated .pg_query.Node args = 7 [json_name = "args"];
inline int NullIfExpr::_internal_args_size() const {
  return _internal_args().size();
}
inline int NullIfExpr::args_size() const {
  return _internal_args_size();
}
inline void NullIfExpr::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* NullIfExpr::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.NullIfExpr.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* NullIfExpr::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.NullIfExpr.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& NullIfExpr::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* NullIfExpr::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.NullIfExpr.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& NullIfExpr::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.NullIfExpr.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
NullIfExpr::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
NullIfExpr::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// int32 location = 8 [json_name = "location"];
inline void NullIfExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t NullIfExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.location)
  return _internal_location();
}
inline void NullIfExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.location)
}
inline ::int32_t NullIfExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void NullIfExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// ScalarArrayOpExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool ScalarArrayOpExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void ScalarArrayOpExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& ScalarArrayOpExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ScalarArrayOpExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.xpr)
  return _internal_xpr();
}
inline void ScalarArrayOpExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ScalarArrayOpExpr.xpr)
}
inline ::pg_query::Node* ScalarArrayOpExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ScalarArrayOpExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ScalarArrayOpExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ScalarArrayOpExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* ScalarArrayOpExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.ScalarArrayOpExpr.xpr)
  return _msg;
}
inline void ScalarArrayOpExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ScalarArrayOpExpr.xpr)
}

// uint32 opno = 2 [json_name = "opno"];
inline void ScalarArrayOpExpr::clear_opno() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opno_ = 0u;
}
inline ::uint32_t ScalarArrayOpExpr::opno() const {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.opno)
  return _internal_opno();
}
inline void ScalarArrayOpExpr::set_opno(::uint32_t value) {
  _internal_set_opno(value);
  // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.opno)
}
inline ::uint32_t ScalarArrayOpExpr::_internal_opno() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opno_;
}
inline void ScalarArrayOpExpr::_internal_set_opno(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.opno_ = value;
}

// bool use_or = 3 [json_name = "useOr"];
inline void ScalarArrayOpExpr::clear_use_or() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.use_or_ = false;
}
inline bool ScalarArrayOpExpr::use_or() const {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.use_or)
  return _internal_use_or();
}
inline void ScalarArrayOpExpr::set_use_or(bool value) {
  _internal_set_use_or(value);
  // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.use_or)
}
inline bool ScalarArrayOpExpr::_internal_use_or() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.use_or_;
}
inline void ScalarArrayOpExpr::_internal_set_use_or(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.use_or_ = value;
}

// uint32 inputcollid = 4 [json_name = "inputcollid"];
inline void ScalarArrayOpExpr::clear_inputcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inputcollid_ = 0u;
}
inline ::uint32_t ScalarArrayOpExpr::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.inputcollid)
  return _internal_inputcollid();
}
inline void ScalarArrayOpExpr::set_inputcollid(::uint32_t value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.inputcollid)
}
inline ::uint32_t ScalarArrayOpExpr::_internal_inputcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inputcollid_;
}
inline void ScalarArrayOpExpr::_internal_set_inputcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inputcollid_ = value;
}

// repeated .pg_query.Node args = 5 [json_name = "args"];
inline int ScalarArrayOpExpr::_internal_args_size() const {
  return _internal_args().size();
}
inline int ScalarArrayOpExpr::args_size() const {
  return _internal_args_size();
}
inline void ScalarArrayOpExpr::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* ScalarArrayOpExpr::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ScalarArrayOpExpr.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ScalarArrayOpExpr::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ScalarArrayOpExpr.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& ScalarArrayOpExpr::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* ScalarArrayOpExpr::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ScalarArrayOpExpr.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ScalarArrayOpExpr::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ScalarArrayOpExpr.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ScalarArrayOpExpr::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ScalarArrayOpExpr::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// int32 location = 6 [json_name = "location"];
inline void ScalarArrayOpExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t ScalarArrayOpExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.location)
  return _internal_location();
}
inline void ScalarArrayOpExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.location)
}
inline ::int32_t ScalarArrayOpExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void ScalarArrayOpExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// BoolExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool BoolExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void BoolExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& BoolExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& BoolExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.BoolExpr.xpr)
  return _internal_xpr();
}
inline void BoolExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.BoolExpr.xpr)
}
inline ::pg_query::Node* BoolExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* BoolExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.BoolExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* BoolExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* BoolExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.BoolExpr.xpr)
  return _msg;
}
inline void BoolExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.BoolExpr.xpr)
}

// .pg_query.BoolExprType boolop = 2 [json_name = "boolop"];
inline void BoolExpr::clear_boolop() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.boolop_ = 0;
}
inline ::pg_query::BoolExprType BoolExpr::boolop() const {
  // @@protoc_insertion_point(field_get:pg_query.BoolExpr.boolop)
  return _internal_boolop();
}
inline void BoolExpr::set_boolop(::pg_query::BoolExprType value) {
  _internal_set_boolop(value);
  // @@protoc_insertion_point(field_set:pg_query.BoolExpr.boolop)
}
inline ::pg_query::BoolExprType BoolExpr::_internal_boolop() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::BoolExprType>(_impl_.boolop_);
}
inline void BoolExpr::_internal_set_boolop(::pg_query::BoolExprType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.boolop_ = value;
}

// repeated .pg_query.Node args = 3 [json_name = "args"];
inline int BoolExpr::_internal_args_size() const {
  return _internal_args().size();
}
inline int BoolExpr::args_size() const {
  return _internal_args_size();
}
inline void BoolExpr::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* BoolExpr::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.BoolExpr.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* BoolExpr::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.BoolExpr.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& BoolExpr::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.BoolExpr.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* BoolExpr::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.BoolExpr.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& BoolExpr::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.BoolExpr.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
BoolExpr::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
BoolExpr::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// int32 location = 4 [json_name = "location"];
inline void BoolExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t BoolExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.BoolExpr.location)
  return _internal_location();
}
inline void BoolExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.BoolExpr.location)
}
inline ::int32_t BoolExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void BoolExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// SubLink

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool SubLink::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void SubLink::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& SubLink::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubLink::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.xpr)
  return _internal_xpr();
}
inline void SubLink::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubLink.xpr)
}
inline ::pg_query::Node* SubLink::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SubLink::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SubLink.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubLink::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* SubLink::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.SubLink.xpr)
  return _msg;
}
inline void SubLink::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.sub_link_type_ = 0;
}
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::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)
}
inline ::pg_query::SubLinkType SubLink::_internal_sub_link_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::SubLinkType>(_impl_.sub_link_type_);
}
inline void SubLink::_internal_set_sub_link_type(::pg_query::SubLinkType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.sub_link_type_ = value;
}

// int32 sub_link_id = 3 [json_name = "subLinkId"];
inline void SubLink::clear_sub_link_id() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.sub_link_id_ = 0;
}
inline ::int32_t SubLink::sub_link_id() const {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.sub_link_id)
  return _internal_sub_link_id();
}
inline void SubLink::set_sub_link_id(::int32_t value) {
  _internal_set_sub_link_id(value);
  // @@protoc_insertion_point(field_set:pg_query.SubLink.sub_link_id)
}
inline ::int32_t SubLink::_internal_sub_link_id() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.sub_link_id_;
}
inline void SubLink::_internal_set_sub_link_id(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.sub_link_id_ = value;
}

// .pg_query.Node testexpr = 4 [json_name = "testexpr"];
inline bool SubLink::has_testexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.testexpr_ != nullptr);
  return value;
}
inline void SubLink::clear_testexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.testexpr_ != nullptr) _impl_.testexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& SubLink::_internal_testexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.testexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubLink::testexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.testexpr)
  return _internal_testexpr();
}
inline void SubLink::unsafe_arena_set_allocated_testexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.testexpr_);
  }
  _impl_.testexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubLink.testexpr)
}
inline ::pg_query::Node* SubLink::release_testexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.testexpr_;
  _impl_.testexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SubLink::unsafe_arena_release_testexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SubLink.testexpr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.testexpr_;
  _impl_.testexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubLink::_internal_mutable_testexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.testexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.testexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.testexpr_;
}
inline ::pg_query::Node* SubLink::mutable_testexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_testexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.SubLink.testexpr)
  return _msg;
}
inline void SubLink::set_allocated_testexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.testexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.testexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_oper_name().size();
}
inline int SubLink::oper_name_size() const {
  return _internal_oper_name_size();
}
inline void SubLink::clear_oper_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.oper_name_.Clear();
}
inline ::pg_query::Node* SubLink::mutable_oper_name(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SubLink.oper_name)
  return _internal_mutable_oper_name()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SubLink::mutable_oper_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubLink.oper_name)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_oper_name();
}
inline const ::pg_query::Node& SubLink::oper_name(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.oper_name)
  return _internal_oper_name().Get(index);
}
inline ::pg_query::Node* SubLink::add_oper_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_oper_name()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SubLink.oper_name)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SubLink::oper_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SubLink.oper_name)
  return _internal_oper_name();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SubLink::_internal_oper_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.oper_name_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SubLink::_internal_mutable_oper_name() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.oper_name_;
}

// .pg_query.Node subselect = 6 [json_name = "subselect"];
inline bool SubLink::has_subselect() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.subselect_ != nullptr);
  return value;
}
inline void SubLink::clear_subselect() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.subselect_ != nullptr) _impl_.subselect_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& SubLink::_internal_subselect() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.subselect_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubLink::subselect() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.subselect)
  return _internal_subselect();
}
inline void SubLink::unsafe_arena_set_allocated_subselect(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.subselect_);
  }
  _impl_.subselect_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubLink.subselect)
}
inline ::pg_query::Node* SubLink::release_subselect() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.subselect_;
  _impl_.subselect_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SubLink::unsafe_arena_release_subselect() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SubLink.subselect)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.subselect_;
  _impl_.subselect_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubLink::_internal_mutable_subselect() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.subselect_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.subselect_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.subselect_;
}
inline ::pg_query::Node* SubLink::mutable_subselect() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_subselect();
  // @@protoc_insertion_point(field_mutable:pg_query.SubLink.subselect)
  return _msg;
}
inline void SubLink::set_allocated_subselect(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.subselect_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.subselect_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SubLink.subselect)
}

// int32 location = 7 [json_name = "location"];
inline void SubLink::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t SubLink::location() const {
  // @@protoc_insertion_point(field_get:pg_query.SubLink.location)
  return _internal_location();
}
inline void SubLink::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.SubLink.location)
}
inline ::int32_t SubLink::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void SubLink::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// SubPlan

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool SubPlan::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void SubPlan::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& SubPlan::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubPlan::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.xpr)
  return _internal_xpr();
}
inline void SubPlan::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubPlan.xpr)
}
inline ::pg_query::Node* SubPlan::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SubPlan::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SubPlan.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubPlan::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* SubPlan::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.xpr)
  return _msg;
}
inline void SubPlan::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.sub_link_type_ = 0;
}
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::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)
}
inline ::pg_query::SubLinkType SubPlan::_internal_sub_link_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::SubLinkType>(_impl_.sub_link_type_);
}
inline void SubPlan::_internal_set_sub_link_type(::pg_query::SubLinkType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.sub_link_type_ = value;
}

// .pg_query.Node testexpr = 3 [json_name = "testexpr"];
inline bool SubPlan::has_testexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.testexpr_ != nullptr);
  return value;
}
inline void SubPlan::clear_testexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.testexpr_ != nullptr) _impl_.testexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& SubPlan::_internal_testexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.testexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SubPlan::testexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.testexpr)
  return _internal_testexpr();
}
inline void SubPlan::unsafe_arena_set_allocated_testexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.testexpr_);
  }
  _impl_.testexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubPlan.testexpr)
}
inline ::pg_query::Node* SubPlan::release_testexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.testexpr_;
  _impl_.testexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SubPlan::unsafe_arena_release_testexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SubPlan.testexpr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.testexpr_;
  _impl_.testexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SubPlan::_internal_mutable_testexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.testexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.testexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.testexpr_;
}
inline ::pg_query::Node* SubPlan::mutable_testexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_testexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.testexpr)
  return _msg;
}
inline void SubPlan::set_allocated_testexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.testexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.testexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_param_ids().size();
}
inline int SubPlan::param_ids_size() const {
  return _internal_param_ids_size();
}
inline void SubPlan::clear_param_ids() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.param_ids_.Clear();
}
inline ::pg_query::Node* SubPlan::mutable_param_ids(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.param_ids)
  return _internal_mutable_param_ids()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SubPlan::mutable_param_ids()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubPlan.param_ids)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_param_ids();
}
inline const ::pg_query::Node& SubPlan::param_ids(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.param_ids)
  return _internal_param_ids().Get(index);
}
inline ::pg_query::Node* SubPlan::add_param_ids() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_param_ids()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SubPlan.param_ids)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SubPlan::param_ids() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SubPlan.param_ids)
  return _internal_param_ids();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SubPlan::_internal_param_ids() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.param_ids_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SubPlan::_internal_mutable_param_ids() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.param_ids_;
}

// int32 plan_id = 5 [json_name = "plan_id"];
inline void SubPlan::clear_plan_id() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.plan_id_ = 0;
}
inline ::int32_t SubPlan::plan_id() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.plan_id)
  return _internal_plan_id();
}
inline void SubPlan::set_plan_id(::int32_t value) {
  _internal_set_plan_id(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.plan_id)
}
inline ::int32_t SubPlan::_internal_plan_id() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.plan_id_;
}
inline void SubPlan::_internal_set_plan_id(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.plan_id_ = value;
}

// string plan_name = 6 [json_name = "plan_name"];
inline void SubPlan::clear_plan_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.plan_name_.ClearToEmpty();
}
inline const std::string& SubPlan::plan_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.plan_name)
  return _internal_plan_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void SubPlan::set_plan_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.plan_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.plan_name)
}
inline std::string* SubPlan::mutable_plan_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_plan_name();
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.plan_name)
  return _s;
}
inline const std::string& SubPlan::_internal_plan_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.plan_name_.Get();
}
inline void SubPlan::_internal_set_plan_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.plan_name_.Set(value, GetArena());
}
inline std::string* SubPlan::_internal_mutable_plan_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.plan_name_.Mutable( GetArena());
}
inline std::string* SubPlan::release_plan_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SubPlan.plan_name)
  return _impl_.plan_name_.Release();
}
inline void SubPlan::set_allocated_plan_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.plan_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.plan_name_.IsDefault()) {
          _impl_.plan_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.first_col_type_ = 0u;
}
inline ::uint32_t SubPlan::first_col_type() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.first_col_type)
  return _internal_first_col_type();
}
inline void SubPlan::set_first_col_type(::uint32_t value) {
  _internal_set_first_col_type(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.first_col_type)
}
inline ::uint32_t SubPlan::_internal_first_col_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.first_col_type_;
}
inline void SubPlan::_internal_set_first_col_type(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.first_col_type_ = value;
}

// int32 first_col_typmod = 8 [json_name = "firstColTypmod"];
inline void SubPlan::clear_first_col_typmod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.first_col_typmod_ = 0;
}
inline ::int32_t SubPlan::first_col_typmod() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.first_col_typmod)
  return _internal_first_col_typmod();
}
inline void SubPlan::set_first_col_typmod(::int32_t value) {
  _internal_set_first_col_typmod(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.first_col_typmod)
}
inline ::int32_t SubPlan::_internal_first_col_typmod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.first_col_typmod_;
}
inline void SubPlan::_internal_set_first_col_typmod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.first_col_typmod_ = value;
}

// uint32 first_col_collation = 9 [json_name = "firstColCollation"];
inline void SubPlan::clear_first_col_collation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.first_col_collation_ = 0u;
}
inline ::uint32_t SubPlan::first_col_collation() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.first_col_collation)
  return _internal_first_col_collation();
}
inline void SubPlan::set_first_col_collation(::uint32_t value) {
  _internal_set_first_col_collation(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.first_col_collation)
}
inline ::uint32_t SubPlan::_internal_first_col_collation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.first_col_collation_;
}
inline void SubPlan::_internal_set_first_col_collation(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.first_col_collation_ = value;
}

// bool use_hash_table = 10 [json_name = "useHashTable"];
inline void SubPlan::clear_use_hash_table() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.use_hash_table_ = false;
}
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::set_use_hash_table(bool value) {
  _internal_set_use_hash_table(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.use_hash_table)
}
inline bool SubPlan::_internal_use_hash_table() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.use_hash_table_;
}
inline void SubPlan::_internal_set_use_hash_table(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.use_hash_table_ = value;
}

// bool unknown_eq_false = 11 [json_name = "unknownEqFalse"];
inline void SubPlan::clear_unknown_eq_false() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.unknown_eq_false_ = 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::set_unknown_eq_false(bool value) {
  _internal_set_unknown_eq_false(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.unknown_eq_false)
}
inline bool SubPlan::_internal_unknown_eq_false() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.unknown_eq_false_;
}
inline void SubPlan::_internal_set_unknown_eq_false(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.unknown_eq_false_ = value;
}

// bool parallel_safe = 12 [json_name = "parallel_safe"];
inline void SubPlan::clear_parallel_safe() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.parallel_safe_ = false;
}
inline bool SubPlan::parallel_safe() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.parallel_safe)
  return _internal_parallel_safe();
}
inline void SubPlan::set_parallel_safe(bool value) {
  _internal_set_parallel_safe(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.parallel_safe)
}
inline bool SubPlan::_internal_parallel_safe() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.parallel_safe_;
}
inline void SubPlan::_internal_set_parallel_safe(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.parallel_safe_ = value;
}

// repeated .pg_query.Node set_param = 13 [json_name = "setParam"];
inline int SubPlan::_internal_set_param_size() const {
  return _internal_set_param().size();
}
inline int SubPlan::set_param_size() const {
  return _internal_set_param_size();
}
inline void SubPlan::clear_set_param() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.set_param_.Clear();
}
inline ::pg_query::Node* SubPlan::mutable_set_param(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.set_param)
  return _internal_mutable_set_param()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SubPlan::mutable_set_param()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubPlan.set_param)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_set_param();
}
inline const ::pg_query::Node& SubPlan::set_param(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.set_param)
  return _internal_set_param().Get(index);
}
inline ::pg_query::Node* SubPlan::add_set_param() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_set_param()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SubPlan.set_param)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SubPlan::set_param() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SubPlan.set_param)
  return _internal_set_param();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SubPlan::_internal_set_param() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.set_param_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SubPlan::_internal_mutable_set_param() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.set_param_;
}

// repeated .pg_query.Node par_param = 14 [json_name = "parParam"];
inline int SubPlan::_internal_par_param_size() const {
  return _internal_par_param().size();
}
inline int SubPlan::par_param_size() const {
  return _internal_par_param_size();
}
inline void SubPlan::clear_par_param() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.par_param_.Clear();
}
inline ::pg_query::Node* SubPlan::mutable_par_param(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.par_param)
  return _internal_mutable_par_param()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SubPlan::mutable_par_param()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubPlan.par_param)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_par_param();
}
inline const ::pg_query::Node& SubPlan::par_param(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.par_param)
  return _internal_par_param().Get(index);
}
inline ::pg_query::Node* SubPlan::add_par_param() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_par_param()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SubPlan.par_param)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SubPlan::par_param() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SubPlan.par_param)
  return _internal_par_param();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SubPlan::_internal_par_param() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.par_param_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SubPlan::_internal_mutable_par_param() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.par_param_;
}

// repeated .pg_query.Node args = 15 [json_name = "args"];
inline int SubPlan::_internal_args_size() const {
  return _internal_args().size();
}
inline int SubPlan::args_size() const {
  return _internal_args_size();
}
inline void SubPlan::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* SubPlan::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SubPlan::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SubPlan.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& SubPlan::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* SubPlan::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SubPlan.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SubPlan::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SubPlan.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SubPlan::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SubPlan::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// double startup_cost = 16 [json_name = "startup_cost"];
inline void SubPlan::clear_startup_cost() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.startup_cost_ = 0;
}
inline double SubPlan::startup_cost() const {
  // @@protoc_insertion_point(field_get:pg_query.SubPlan.startup_cost)
  return _internal_startup_cost();
}
inline void SubPlan::set_startup_cost(double value) {
  _internal_set_startup_cost(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.startup_cost)
}
inline double SubPlan::_internal_startup_cost() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.startup_cost_;
}
inline void SubPlan::_internal_set_startup_cost(double value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.startup_cost_ = value;
}

// double per_call_cost = 17 [json_name = "per_call_cost"];
inline void SubPlan::clear_per_call_cost() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.per_call_cost_ = 0;
}
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::set_per_call_cost(double value) {
  _internal_set_per_call_cost(value);
  // @@protoc_insertion_point(field_set:pg_query.SubPlan.per_call_cost)
}
inline double SubPlan::_internal_per_call_cost() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.per_call_cost_;
}
inline void SubPlan::_internal_set_per_call_cost(double value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.per_call_cost_ = value;
}

// -------------------------------------------------------------------

// AlternativeSubPlan

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool AlternativeSubPlan::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void AlternativeSubPlan::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& AlternativeSubPlan::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlternativeSubPlan::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlternativeSubPlan.xpr)
  return _internal_xpr();
}
inline void AlternativeSubPlan::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlternativeSubPlan.xpr)
}
inline ::pg_query::Node* AlternativeSubPlan::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* AlternativeSubPlan::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlternativeSubPlan.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlternativeSubPlan::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* AlternativeSubPlan::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.AlternativeSubPlan.xpr)
  return _msg;
}
inline void AlternativeSubPlan::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_subplans().size();
}
inline int AlternativeSubPlan::subplans_size() const {
  return _internal_subplans_size();
}
inline void AlternativeSubPlan::clear_subplans() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subplans_.Clear();
}
inline ::pg_query::Node* AlternativeSubPlan::mutable_subplans(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlternativeSubPlan.subplans)
  return _internal_mutable_subplans()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlternativeSubPlan::mutable_subplans()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlternativeSubPlan.subplans)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_subplans();
}
inline const ::pg_query::Node& AlternativeSubPlan::subplans(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlternativeSubPlan.subplans)
  return _internal_subplans().Get(index);
}
inline ::pg_query::Node* AlternativeSubPlan::add_subplans() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_subplans()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlternativeSubPlan.subplans)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlternativeSubPlan::subplans() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlternativeSubPlan.subplans)
  return _internal_subplans();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlternativeSubPlan::_internal_subplans() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.subplans_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlternativeSubPlan::_internal_mutable_subplans() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.subplans_;
}

// -------------------------------------------------------------------

// FieldSelect

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool FieldSelect::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void FieldSelect::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& FieldSelect::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FieldSelect::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FieldSelect.xpr)
  return _internal_xpr();
}
inline void FieldSelect::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FieldSelect.xpr)
}
inline ::pg_query::Node* FieldSelect::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* FieldSelect::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.FieldSelect.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FieldSelect::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* FieldSelect::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.FieldSelect.xpr)
  return _msg;
}
inline void FieldSelect::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.FieldSelect.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool FieldSelect::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void FieldSelect::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& FieldSelect::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FieldSelect::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FieldSelect.arg)
  return _internal_arg();
}
inline void FieldSelect::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FieldSelect.arg)
}
inline ::pg_query::Node* FieldSelect::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* FieldSelect::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.FieldSelect.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FieldSelect::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* FieldSelect::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.FieldSelect.arg)
  return _msg;
}
inline void FieldSelect::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.FieldSelect.arg)
}

// int32 fieldnum = 3 [json_name = "fieldnum"];
inline void FieldSelect::clear_fieldnum() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fieldnum_ = 0;
}
inline ::int32_t FieldSelect::fieldnum() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldSelect.fieldnum)
  return _internal_fieldnum();
}
inline void FieldSelect::set_fieldnum(::int32_t value) {
  _internal_set_fieldnum(value);
  // @@protoc_insertion_point(field_set:pg_query.FieldSelect.fieldnum)
}
inline ::int32_t FieldSelect::_internal_fieldnum() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fieldnum_;
}
inline void FieldSelect::_internal_set_fieldnum(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fieldnum_ = value;
}

// uint32 resulttype = 4 [json_name = "resulttype"];
inline void FieldSelect::clear_resulttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resulttype_ = 0u;
}
inline ::uint32_t FieldSelect::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldSelect.resulttype)
  return _internal_resulttype();
}
inline void FieldSelect::set_resulttype(::uint32_t value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.FieldSelect.resulttype)
}
inline ::uint32_t FieldSelect::_internal_resulttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resulttype_;
}
inline void FieldSelect::_internal_set_resulttype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resulttype_ = value;
}

// int32 resulttypmod = 5 [json_name = "resulttypmod"];
inline void FieldSelect::clear_resulttypmod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resulttypmod_ = 0;
}
inline ::int32_t FieldSelect::resulttypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldSelect.resulttypmod)
  return _internal_resulttypmod();
}
inline void FieldSelect::set_resulttypmod(::int32_t value) {
  _internal_set_resulttypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.FieldSelect.resulttypmod)
}
inline ::int32_t FieldSelect::_internal_resulttypmod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resulttypmod_;
}
inline void FieldSelect::_internal_set_resulttypmod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resulttypmod_ = value;
}

// uint32 resultcollid = 6 [json_name = "resultcollid"];
inline void FieldSelect::clear_resultcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resultcollid_ = 0u;
}
inline ::uint32_t FieldSelect::resultcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldSelect.resultcollid)
  return _internal_resultcollid();
}
inline void FieldSelect::set_resultcollid(::uint32_t value) {
  _internal_set_resultcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.FieldSelect.resultcollid)
}
inline ::uint32_t FieldSelect::_internal_resultcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resultcollid_;
}
inline void FieldSelect::_internal_set_resultcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resultcollid_ = value;
}

// -------------------------------------------------------------------

// FieldStore

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool FieldStore::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void FieldStore::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& FieldStore::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FieldStore::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FieldStore.xpr)
  return _internal_xpr();
}
inline void FieldStore::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FieldStore.xpr)
}
inline ::pg_query::Node* FieldStore::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* FieldStore::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.FieldStore.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FieldStore::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* FieldStore::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.FieldStore.xpr)
  return _msg;
}
inline void FieldStore::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.FieldStore.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool FieldStore::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void FieldStore::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& FieldStore::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FieldStore::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FieldStore.arg)
  return _internal_arg();
}
inline void FieldStore::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FieldStore.arg)
}
inline ::pg_query::Node* FieldStore::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* FieldStore::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.FieldStore.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FieldStore::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* FieldStore::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.FieldStore.arg)
  return _msg;
}
inline void FieldStore::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_newvals().size();
}
inline int FieldStore::newvals_size() const {
  return _internal_newvals_size();
}
inline void FieldStore::clear_newvals() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.newvals_.Clear();
}
inline ::pg_query::Node* FieldStore::mutable_newvals(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.FieldStore.newvals)
  return _internal_mutable_newvals()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* FieldStore::mutable_newvals()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FieldStore.newvals)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_newvals();
}
inline const ::pg_query::Node& FieldStore::newvals(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FieldStore.newvals)
  return _internal_newvals().Get(index);
}
inline ::pg_query::Node* FieldStore::add_newvals() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_newvals()->Add();
  // @@protoc_insertion_point(field_add:pg_query.FieldStore.newvals)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& FieldStore::newvals() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.FieldStore.newvals)
  return _internal_newvals();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
FieldStore::_internal_newvals() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.newvals_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
FieldStore::_internal_mutable_newvals() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.newvals_;
}

// repeated .pg_query.Node fieldnums = 4 [json_name = "fieldnums"];
inline int FieldStore::_internal_fieldnums_size() const {
  return _internal_fieldnums().size();
}
inline int FieldStore::fieldnums_size() const {
  return _internal_fieldnums_size();
}
inline void FieldStore::clear_fieldnums() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fieldnums_.Clear();
}
inline ::pg_query::Node* FieldStore::mutable_fieldnums(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.FieldStore.fieldnums)
  return _internal_mutable_fieldnums()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* FieldStore::mutable_fieldnums()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FieldStore.fieldnums)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_fieldnums();
}
inline const ::pg_query::Node& FieldStore::fieldnums(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FieldStore.fieldnums)
  return _internal_fieldnums().Get(index);
}
inline ::pg_query::Node* FieldStore::add_fieldnums() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_fieldnums()->Add();
  // @@protoc_insertion_point(field_add:pg_query.FieldStore.fieldnums)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& FieldStore::fieldnums() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.FieldStore.fieldnums)
  return _internal_fieldnums();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
FieldStore::_internal_fieldnums() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fieldnums_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
FieldStore::_internal_mutable_fieldnums() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.fieldnums_;
}

// uint32 resulttype = 5 [json_name = "resulttype"];
inline void FieldStore::clear_resulttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resulttype_ = 0u;
}
inline ::uint32_t FieldStore::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.FieldStore.resulttype)
  return _internal_resulttype();
}
inline void FieldStore::set_resulttype(::uint32_t value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.FieldStore.resulttype)
}
inline ::uint32_t FieldStore::_internal_resulttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resulttype_;
}
inline void FieldStore::_internal_set_resulttype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resulttype_ = value;
}

// -------------------------------------------------------------------

// RelabelType

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool RelabelType::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void RelabelType::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& RelabelType::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RelabelType::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.xpr)
  return _internal_xpr();
}
inline void RelabelType::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RelabelType.xpr)
}
inline ::pg_query::Node* RelabelType::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RelabelType::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RelabelType.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RelabelType::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* RelabelType::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.RelabelType.xpr)
  return _msg;
}
inline void RelabelType::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RelabelType.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool RelabelType::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void RelabelType::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& RelabelType::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RelabelType::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.arg)
  return _internal_arg();
}
inline void RelabelType::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RelabelType.arg)
}
inline ::pg_query::Node* RelabelType::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RelabelType::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RelabelType.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RelabelType::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* RelabelType::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.RelabelType.arg)
  return _msg;
}
inline void RelabelType::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RelabelType.arg)
}

// uint32 resulttype = 3 [json_name = "resulttype"];
inline void RelabelType::clear_resulttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resulttype_ = 0u;
}
inline ::uint32_t RelabelType::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.resulttype)
  return _internal_resulttype();
}
inline void RelabelType::set_resulttype(::uint32_t value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.RelabelType.resulttype)
}
inline ::uint32_t RelabelType::_internal_resulttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resulttype_;
}
inline void RelabelType::_internal_set_resulttype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resulttype_ = value;
}

// int32 resulttypmod = 4 [json_name = "resulttypmod"];
inline void RelabelType::clear_resulttypmod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resulttypmod_ = 0;
}
inline ::int32_t RelabelType::resulttypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.resulttypmod)
  return _internal_resulttypmod();
}
inline void RelabelType::set_resulttypmod(::int32_t value) {
  _internal_set_resulttypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.RelabelType.resulttypmod)
}
inline ::int32_t RelabelType::_internal_resulttypmod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resulttypmod_;
}
inline void RelabelType::_internal_set_resulttypmod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resulttypmod_ = value;
}

// uint32 resultcollid = 5 [json_name = "resultcollid"];
inline void RelabelType::clear_resultcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resultcollid_ = 0u;
}
inline ::uint32_t RelabelType::resultcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.resultcollid)
  return _internal_resultcollid();
}
inline void RelabelType::set_resultcollid(::uint32_t value) {
  _internal_set_resultcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.RelabelType.resultcollid)
}
inline ::uint32_t RelabelType::_internal_resultcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resultcollid_;
}
inline void RelabelType::_internal_set_resultcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resultcollid_ = value;
}

// .pg_query.CoercionForm relabelformat = 6 [json_name = "relabelformat"];
inline void RelabelType::clear_relabelformat() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relabelformat_ = 0;
}
inline ::pg_query::CoercionForm RelabelType::relabelformat() const {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.relabelformat)
  return _internal_relabelformat();
}
inline void RelabelType::set_relabelformat(::pg_query::CoercionForm value) {
  _internal_set_relabelformat(value);
  // @@protoc_insertion_point(field_set:pg_query.RelabelType.relabelformat)
}
inline ::pg_query::CoercionForm RelabelType::_internal_relabelformat() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CoercionForm>(_impl_.relabelformat_);
}
inline void RelabelType::_internal_set_relabelformat(::pg_query::CoercionForm value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relabelformat_ = value;
}

// int32 location = 7 [json_name = "location"];
inline void RelabelType::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t RelabelType::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RelabelType.location)
  return _internal_location();
}
inline void RelabelType::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RelabelType.location)
}
inline ::int32_t RelabelType::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void RelabelType::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CoerceViaIO

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CoerceViaIO::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void CoerceViaIO::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CoerceViaIO::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CoerceViaIO::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.xpr)
  return _internal_xpr();
}
inline void CoerceViaIO::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceViaIO.xpr)
}
inline ::pg_query::Node* CoerceViaIO::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CoerceViaIO::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CoerceViaIO.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CoerceViaIO::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* CoerceViaIO::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.CoerceViaIO.xpr)
  return _msg;
}
inline void CoerceViaIO::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceViaIO.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool CoerceViaIO::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void CoerceViaIO::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& CoerceViaIO::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CoerceViaIO::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.arg)
  return _internal_arg();
}
inline void CoerceViaIO::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceViaIO.arg)
}
inline ::pg_query::Node* CoerceViaIO::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CoerceViaIO::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CoerceViaIO.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CoerceViaIO::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* CoerceViaIO::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.CoerceViaIO.arg)
  return _msg;
}
inline void CoerceViaIO::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceViaIO.arg)
}

// uint32 resulttype = 3 [json_name = "resulttype"];
inline void CoerceViaIO::clear_resulttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resulttype_ = 0u;
}
inline ::uint32_t CoerceViaIO::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.resulttype)
  return _internal_resulttype();
}
inline void CoerceViaIO::set_resulttype(::uint32_t value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceViaIO.resulttype)
}
inline ::uint32_t CoerceViaIO::_internal_resulttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resulttype_;
}
inline void CoerceViaIO::_internal_set_resulttype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resulttype_ = value;
}

// uint32 resultcollid = 4 [json_name = "resultcollid"];
inline void CoerceViaIO::clear_resultcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resultcollid_ = 0u;
}
inline ::uint32_t CoerceViaIO::resultcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.resultcollid)
  return _internal_resultcollid();
}
inline void CoerceViaIO::set_resultcollid(::uint32_t value) {
  _internal_set_resultcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceViaIO.resultcollid)
}
inline ::uint32_t CoerceViaIO::_internal_resultcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resultcollid_;
}
inline void CoerceViaIO::_internal_set_resultcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resultcollid_ = value;
}

// .pg_query.CoercionForm coerceformat = 5 [json_name = "coerceformat"];
inline void CoerceViaIO::clear_coerceformat() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coerceformat_ = 0;
}
inline ::pg_query::CoercionForm CoerceViaIO::coerceformat() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.coerceformat)
  return _internal_coerceformat();
}
inline void CoerceViaIO::set_coerceformat(::pg_query::CoercionForm value) {
  _internal_set_coerceformat(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceViaIO.coerceformat)
}
inline ::pg_query::CoercionForm CoerceViaIO::_internal_coerceformat() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CoercionForm>(_impl_.coerceformat_);
}
inline void CoerceViaIO::_internal_set_coerceformat(::pg_query::CoercionForm value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.coerceformat_ = value;
}

// int32 location = 6 [json_name = "location"];
inline void CoerceViaIO::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t CoerceViaIO::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.location)
  return _internal_location();
}
inline void CoerceViaIO::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceViaIO.location)
}
inline ::int32_t CoerceViaIO::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void CoerceViaIO::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// ArrayCoerceExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool ArrayCoerceExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void ArrayCoerceExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& ArrayCoerceExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ArrayCoerceExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.xpr)
  return _internal_xpr();
}
inline void ArrayCoerceExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ArrayCoerceExpr.xpr)
}
inline ::pg_query::Node* ArrayCoerceExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ArrayCoerceExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ArrayCoerceExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ArrayCoerceExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* ArrayCoerceExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.ArrayCoerceExpr.xpr)
  return _msg;
}
inline void ArrayCoerceExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ArrayCoerceExpr.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool ArrayCoerceExpr::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void ArrayCoerceExpr::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& ArrayCoerceExpr::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ArrayCoerceExpr::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.arg)
  return _internal_arg();
}
inline void ArrayCoerceExpr::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ArrayCoerceExpr.arg)
}
inline ::pg_query::Node* ArrayCoerceExpr::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ArrayCoerceExpr::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ArrayCoerceExpr.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ArrayCoerceExpr::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* ArrayCoerceExpr::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.ArrayCoerceExpr.arg)
  return _msg;
}
inline void ArrayCoerceExpr::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ArrayCoerceExpr.arg)
}

// .pg_query.Node elemexpr = 3 [json_name = "elemexpr"];
inline bool ArrayCoerceExpr::has_elemexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.elemexpr_ != nullptr);
  return value;
}
inline void ArrayCoerceExpr::clear_elemexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.elemexpr_ != nullptr) _impl_.elemexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& ArrayCoerceExpr::_internal_elemexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.elemexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ArrayCoerceExpr::elemexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.elemexpr)
  return _internal_elemexpr();
}
inline void ArrayCoerceExpr::unsafe_arena_set_allocated_elemexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.elemexpr_);
  }
  _impl_.elemexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ArrayCoerceExpr.elemexpr)
}
inline ::pg_query::Node* ArrayCoerceExpr::release_elemexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.elemexpr_;
  _impl_.elemexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ArrayCoerceExpr::unsafe_arena_release_elemexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ArrayCoerceExpr.elemexpr)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.elemexpr_;
  _impl_.elemexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ArrayCoerceExpr::_internal_mutable_elemexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.elemexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.elemexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.elemexpr_;
}
inline ::pg_query::Node* ArrayCoerceExpr::mutable_elemexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_elemexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.ArrayCoerceExpr.elemexpr)
  return _msg;
}
inline void ArrayCoerceExpr::set_allocated_elemexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.elemexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.elemexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ArrayCoerceExpr.elemexpr)
}

// uint32 resulttype = 4 [json_name = "resulttype"];
inline void ArrayCoerceExpr::clear_resulttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resulttype_ = 0u;
}
inline ::uint32_t ArrayCoerceExpr::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.resulttype)
  return _internal_resulttype();
}
inline void ArrayCoerceExpr::set_resulttype(::uint32_t value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.resulttype)
}
inline ::uint32_t ArrayCoerceExpr::_internal_resulttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resulttype_;
}
inline void ArrayCoerceExpr::_internal_set_resulttype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resulttype_ = value;
}

// int32 resulttypmod = 5 [json_name = "resulttypmod"];
inline void ArrayCoerceExpr::clear_resulttypmod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resulttypmod_ = 0;
}
inline ::int32_t ArrayCoerceExpr::resulttypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.resulttypmod)
  return _internal_resulttypmod();
}
inline void ArrayCoerceExpr::set_resulttypmod(::int32_t value) {
  _internal_set_resulttypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.resulttypmod)
}
inline ::int32_t ArrayCoerceExpr::_internal_resulttypmod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resulttypmod_;
}
inline void ArrayCoerceExpr::_internal_set_resulttypmod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resulttypmod_ = value;
}

// uint32 resultcollid = 6 [json_name = "resultcollid"];
inline void ArrayCoerceExpr::clear_resultcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resultcollid_ = 0u;
}
inline ::uint32_t ArrayCoerceExpr::resultcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.resultcollid)
  return _internal_resultcollid();
}
inline void ArrayCoerceExpr::set_resultcollid(::uint32_t value) {
  _internal_set_resultcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.resultcollid)
}
inline ::uint32_t ArrayCoerceExpr::_internal_resultcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resultcollid_;
}
inline void ArrayCoerceExpr::_internal_set_resultcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resultcollid_ = value;
}

// .pg_query.CoercionForm coerceformat = 7 [json_name = "coerceformat"];
inline void ArrayCoerceExpr::clear_coerceformat() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coerceformat_ = 0;
}
inline ::pg_query::CoercionForm ArrayCoerceExpr::coerceformat() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.coerceformat)
  return _internal_coerceformat();
}
inline void ArrayCoerceExpr::set_coerceformat(::pg_query::CoercionForm value) {
  _internal_set_coerceformat(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.coerceformat)
}
inline ::pg_query::CoercionForm ArrayCoerceExpr::_internal_coerceformat() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CoercionForm>(_impl_.coerceformat_);
}
inline void ArrayCoerceExpr::_internal_set_coerceformat(::pg_query::CoercionForm value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.coerceformat_ = value;
}

// int32 location = 8 [json_name = "location"];
inline void ArrayCoerceExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t ArrayCoerceExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.location)
  return _internal_location();
}
inline void ArrayCoerceExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.location)
}
inline ::int32_t ArrayCoerceExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void ArrayCoerceExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// ConvertRowtypeExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool ConvertRowtypeExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void ConvertRowtypeExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& ConvertRowtypeExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ConvertRowtypeExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.xpr)
  return _internal_xpr();
}
inline void ConvertRowtypeExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ConvertRowtypeExpr.xpr)
}
inline ::pg_query::Node* ConvertRowtypeExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ConvertRowtypeExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ConvertRowtypeExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ConvertRowtypeExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* ConvertRowtypeExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.ConvertRowtypeExpr.xpr)
  return _msg;
}
inline void ConvertRowtypeExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ConvertRowtypeExpr.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool ConvertRowtypeExpr::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void ConvertRowtypeExpr::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& ConvertRowtypeExpr::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ConvertRowtypeExpr::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.arg)
  return _internal_arg();
}
inline void ConvertRowtypeExpr::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ConvertRowtypeExpr.arg)
}
inline ::pg_query::Node* ConvertRowtypeExpr::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ConvertRowtypeExpr::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ConvertRowtypeExpr.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ConvertRowtypeExpr::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* ConvertRowtypeExpr::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.ConvertRowtypeExpr.arg)
  return _msg;
}
inline void ConvertRowtypeExpr::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ConvertRowtypeExpr.arg)
}

// uint32 resulttype = 3 [json_name = "resulttype"];
inline void ConvertRowtypeExpr::clear_resulttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resulttype_ = 0u;
}
inline ::uint32_t ConvertRowtypeExpr::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.resulttype)
  return _internal_resulttype();
}
inline void ConvertRowtypeExpr::set_resulttype(::uint32_t value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.ConvertRowtypeExpr.resulttype)
}
inline ::uint32_t ConvertRowtypeExpr::_internal_resulttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resulttype_;
}
inline void ConvertRowtypeExpr::_internal_set_resulttype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resulttype_ = value;
}

// .pg_query.CoercionForm convertformat = 4 [json_name = "convertformat"];
inline void ConvertRowtypeExpr::clear_convertformat() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.convertformat_ = 0;
}
inline ::pg_query::CoercionForm ConvertRowtypeExpr::convertformat() const {
  // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.convertformat)
  return _internal_convertformat();
}
inline void ConvertRowtypeExpr::set_convertformat(::pg_query::CoercionForm value) {
  _internal_set_convertformat(value);
  // @@protoc_insertion_point(field_set:pg_query.ConvertRowtypeExpr.convertformat)
}
inline ::pg_query::CoercionForm ConvertRowtypeExpr::_internal_convertformat() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CoercionForm>(_impl_.convertformat_);
}
inline void ConvertRowtypeExpr::_internal_set_convertformat(::pg_query::CoercionForm value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.convertformat_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void ConvertRowtypeExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t ConvertRowtypeExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.location)
  return _internal_location();
}
inline void ConvertRowtypeExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ConvertRowtypeExpr.location)
}
inline ::int32_t ConvertRowtypeExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void ConvertRowtypeExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CollateExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CollateExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void CollateExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CollateExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CollateExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CollateExpr.xpr)
  return _internal_xpr();
}
inline void CollateExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CollateExpr.xpr)
}
inline ::pg_query::Node* CollateExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CollateExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CollateExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CollateExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* CollateExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.CollateExpr.xpr)
  return _msg;
}
inline void CollateExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CollateExpr.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool CollateExpr::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void CollateExpr::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& CollateExpr::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CollateExpr::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CollateExpr.arg)
  return _internal_arg();
}
inline void CollateExpr::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CollateExpr.arg)
}
inline ::pg_query::Node* CollateExpr::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CollateExpr::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CollateExpr.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CollateExpr::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* CollateExpr::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.CollateExpr.arg)
  return _msg;
}
inline void CollateExpr::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CollateExpr.arg)
}

// uint32 coll_oid = 3 [json_name = "collOid"];
inline void CollateExpr::clear_coll_oid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coll_oid_ = 0u;
}
inline ::uint32_t CollateExpr::coll_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.CollateExpr.coll_oid)
  return _internal_coll_oid();
}
inline void CollateExpr::set_coll_oid(::uint32_t value) {
  _internal_set_coll_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.CollateExpr.coll_oid)
}
inline ::uint32_t CollateExpr::_internal_coll_oid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.coll_oid_;
}
inline void CollateExpr::_internal_set_coll_oid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.coll_oid_ = value;
}

// int32 location = 4 [json_name = "location"];
inline void CollateExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t CollateExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CollateExpr.location)
  return _internal_location();
}
inline void CollateExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CollateExpr.location)
}
inline ::int32_t CollateExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void CollateExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CaseExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CaseExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void CaseExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CaseExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.xpr)
  return _internal_xpr();
}
inline void CaseExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseExpr.xpr)
}
inline ::pg_query::Node* CaseExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CaseExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CaseExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* CaseExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.CaseExpr.xpr)
  return _msg;
}
inline void CaseExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseExpr.xpr)
}

// uint32 casetype = 2 [json_name = "casetype"];
inline void CaseExpr::clear_casetype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.casetype_ = 0u;
}
inline ::uint32_t CaseExpr::casetype() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.casetype)
  return _internal_casetype();
}
inline void CaseExpr::set_casetype(::uint32_t value) {
  _internal_set_casetype(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseExpr.casetype)
}
inline ::uint32_t CaseExpr::_internal_casetype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.casetype_;
}
inline void CaseExpr::_internal_set_casetype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.casetype_ = value;
}

// uint32 casecollid = 3 [json_name = "casecollid"];
inline void CaseExpr::clear_casecollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.casecollid_ = 0u;
}
inline ::uint32_t CaseExpr::casecollid() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.casecollid)
  return _internal_casecollid();
}
inline void CaseExpr::set_casecollid(::uint32_t value) {
  _internal_set_casecollid(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseExpr.casecollid)
}
inline ::uint32_t CaseExpr::_internal_casecollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.casecollid_;
}
inline void CaseExpr::_internal_set_casecollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.casecollid_ = value;
}

// .pg_query.Node arg = 4 [json_name = "arg"];
inline bool CaseExpr::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void CaseExpr::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& CaseExpr::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseExpr::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.arg)
  return _internal_arg();
}
inline void CaseExpr::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseExpr.arg)
}
inline ::pg_query::Node* CaseExpr::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CaseExpr::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CaseExpr.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseExpr::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* CaseExpr::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.CaseExpr.arg)
  return _msg;
}
inline void CaseExpr::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_args().size();
}
inline int CaseExpr::args_size() const {
  return _internal_args_size();
}
inline void CaseExpr::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* CaseExpr::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CaseExpr.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CaseExpr::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CaseExpr.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& CaseExpr::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* CaseExpr::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CaseExpr.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CaseExpr::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CaseExpr.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CaseExpr::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CaseExpr::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// .pg_query.Node defresult = 6 [json_name = "defresult"];
inline bool CaseExpr::has_defresult() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.defresult_ != nullptr);
  return value;
}
inline void CaseExpr::clear_defresult() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.defresult_ != nullptr) _impl_.defresult_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& CaseExpr::_internal_defresult() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.defresult_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseExpr::defresult() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.defresult)
  return _internal_defresult();
}
inline void CaseExpr::unsafe_arena_set_allocated_defresult(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.defresult_);
  }
  _impl_.defresult_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseExpr.defresult)
}
inline ::pg_query::Node* CaseExpr::release_defresult() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.defresult_;
  _impl_.defresult_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CaseExpr::unsafe_arena_release_defresult() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CaseExpr.defresult)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.defresult_;
  _impl_.defresult_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseExpr::_internal_mutable_defresult() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.defresult_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.defresult_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.defresult_;
}
inline ::pg_query::Node* CaseExpr::mutable_defresult() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_defresult();
  // @@protoc_insertion_point(field_mutable:pg_query.CaseExpr.defresult)
  return _msg;
}
inline void CaseExpr::set_allocated_defresult(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.defresult_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.defresult_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseExpr.defresult)
}

// int32 location = 7 [json_name = "location"];
inline void CaseExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t CaseExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseExpr.location)
  return _internal_location();
}
inline void CaseExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseExpr.location)
}
inline ::int32_t CaseExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void CaseExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CaseWhen

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CaseWhen::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void CaseWhen::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CaseWhen::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseWhen::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CaseWhen.xpr)
  return _internal_xpr();
}
inline void CaseWhen::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseWhen.xpr)
}
inline ::pg_query::Node* CaseWhen::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CaseWhen::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CaseWhen.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseWhen::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* CaseWhen::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.CaseWhen.xpr)
  return _msg;
}
inline void CaseWhen::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseWhen.xpr)
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool CaseWhen::has_expr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.expr_ != nullptr);
  return value;
}
inline void CaseWhen::clear_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.expr_ != nullptr) _impl_.expr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& CaseWhen::_internal_expr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseWhen::expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CaseWhen.expr)
  return _internal_expr();
}
inline void CaseWhen::unsafe_arena_set_allocated_expr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.expr_);
  }
  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseWhen.expr)
}
inline ::pg_query::Node* CaseWhen::release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.expr_;
  _impl_.expr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CaseWhen::unsafe_arena_release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CaseWhen.expr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.expr_;
  _impl_.expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseWhen::_internal_mutable_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.expr_;
}
inline ::pg_query::Node* CaseWhen::mutable_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.CaseWhen.expr)
  return _msg;
}
inline void CaseWhen::set_allocated_expr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.expr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseWhen.expr)
}

// .pg_query.Node result = 3 [json_name = "result"];
inline bool CaseWhen::has_result() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.result_ != nullptr);
  return value;
}
inline void CaseWhen::clear_result() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.result_ != nullptr) _impl_.result_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& CaseWhen::_internal_result() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.result_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseWhen::result() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CaseWhen.result)
  return _internal_result();
}
inline void CaseWhen::unsafe_arena_set_allocated_result(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.result_);
  }
  _impl_.result_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseWhen.result)
}
inline ::pg_query::Node* CaseWhen::release_result() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.result_;
  _impl_.result_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CaseWhen::unsafe_arena_release_result() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CaseWhen.result)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.result_;
  _impl_.result_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseWhen::_internal_mutable_result() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.result_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.result_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.result_;
}
inline ::pg_query::Node* CaseWhen::mutable_result() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_result();
  // @@protoc_insertion_point(field_mutable:pg_query.CaseWhen.result)
  return _msg;
}
inline void CaseWhen::set_allocated_result(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.result_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.result_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseWhen.result)
}

// int32 location = 4 [json_name = "location"];
inline void CaseWhen::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t CaseWhen::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseWhen.location)
  return _internal_location();
}
inline void CaseWhen::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseWhen.location)
}
inline ::int32_t CaseWhen::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void CaseWhen::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CaseTestExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CaseTestExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void CaseTestExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CaseTestExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CaseTestExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CaseTestExpr.xpr)
  return _internal_xpr();
}
inline void CaseTestExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseTestExpr.xpr)
}
inline ::pg_query::Node* CaseTestExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CaseTestExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CaseTestExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CaseTestExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* CaseTestExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.CaseTestExpr.xpr)
  return _msg;
}
inline void CaseTestExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CaseTestExpr.xpr)
}

// uint32 type_id = 2 [json_name = "typeId"];
inline void CaseTestExpr::clear_type_id() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_id_ = 0u;
}
inline ::uint32_t CaseTestExpr::type_id() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseTestExpr.type_id)
  return _internal_type_id();
}
inline void CaseTestExpr::set_type_id(::uint32_t value) {
  _internal_set_type_id(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseTestExpr.type_id)
}
inline ::uint32_t CaseTestExpr::_internal_type_id() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_id_;
}
inline void CaseTestExpr::_internal_set_type_id(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_id_ = value;
}

// int32 type_mod = 3 [json_name = "typeMod"];
inline void CaseTestExpr::clear_type_mod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_mod_ = 0;
}
inline ::int32_t CaseTestExpr::type_mod() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseTestExpr.type_mod)
  return _internal_type_mod();
}
inline void CaseTestExpr::set_type_mod(::int32_t value) {
  _internal_set_type_mod(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseTestExpr.type_mod)
}
inline ::int32_t CaseTestExpr::_internal_type_mod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_mod_;
}
inline void CaseTestExpr::_internal_set_type_mod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_mod_ = value;
}

// uint32 collation = 4 [json_name = "collation"];
inline void CaseTestExpr::clear_collation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.collation_ = 0u;
}
inline ::uint32_t CaseTestExpr::collation() const {
  // @@protoc_insertion_point(field_get:pg_query.CaseTestExpr.collation)
  return _internal_collation();
}
inline void CaseTestExpr::set_collation(::uint32_t value) {
  _internal_set_collation(value);
  // @@protoc_insertion_point(field_set:pg_query.CaseTestExpr.collation)
}
inline ::uint32_t CaseTestExpr::_internal_collation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.collation_;
}
inline void CaseTestExpr::_internal_set_collation(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.collation_ = value;
}

// -------------------------------------------------------------------

// ArrayExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool ArrayExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void ArrayExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& ArrayExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ArrayExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.xpr)
  return _internal_xpr();
}
inline void ArrayExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ArrayExpr.xpr)
}
inline ::pg_query::Node* ArrayExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ArrayExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ArrayExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ArrayExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* ArrayExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.ArrayExpr.xpr)
  return _msg;
}
inline void ArrayExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ArrayExpr.xpr)
}

// uint32 array_typeid = 2 [json_name = "array_typeid"];
inline void ArrayExpr::clear_array_typeid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.array_typeid_ = 0u;
}
inline ::uint32_t ArrayExpr::array_typeid() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.array_typeid)
  return _internal_array_typeid();
}
inline void ArrayExpr::set_array_typeid(::uint32_t value) {
  _internal_set_array_typeid(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.array_typeid)
}
inline ::uint32_t ArrayExpr::_internal_array_typeid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.array_typeid_;
}
inline void ArrayExpr::_internal_set_array_typeid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.array_typeid_ = value;
}

// uint32 array_collid = 3 [json_name = "array_collid"];
inline void ArrayExpr::clear_array_collid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.array_collid_ = 0u;
}
inline ::uint32_t ArrayExpr::array_collid() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.array_collid)
  return _internal_array_collid();
}
inline void ArrayExpr::set_array_collid(::uint32_t value) {
  _internal_set_array_collid(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.array_collid)
}
inline ::uint32_t ArrayExpr::_internal_array_collid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.array_collid_;
}
inline void ArrayExpr::_internal_set_array_collid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.array_collid_ = value;
}

// uint32 element_typeid = 4 [json_name = "element_typeid"];
inline void ArrayExpr::clear_element_typeid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.element_typeid_ = 0u;
}
inline ::uint32_t ArrayExpr::element_typeid() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.element_typeid)
  return _internal_element_typeid();
}
inline void ArrayExpr::set_element_typeid(::uint32_t value) {
  _internal_set_element_typeid(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.element_typeid)
}
inline ::uint32_t ArrayExpr::_internal_element_typeid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.element_typeid_;
}
inline void ArrayExpr::_internal_set_element_typeid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.element_typeid_ = value;
}

// repeated .pg_query.Node elements = 5 [json_name = "elements"];
inline int ArrayExpr::_internal_elements_size() const {
  return _internal_elements().size();
}
inline int ArrayExpr::elements_size() const {
  return _internal_elements_size();
}
inline void ArrayExpr::clear_elements() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.elements_.Clear();
}
inline ::pg_query::Node* ArrayExpr::mutable_elements(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ArrayExpr.elements)
  return _internal_mutable_elements()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ArrayExpr::mutable_elements()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ArrayExpr.elements)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_elements();
}
inline const ::pg_query::Node& ArrayExpr::elements(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.elements)
  return _internal_elements().Get(index);
}
inline ::pg_query::Node* ArrayExpr::add_elements() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_elements()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ArrayExpr.elements)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ArrayExpr::elements() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ArrayExpr.elements)
  return _internal_elements();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ArrayExpr::_internal_elements() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.elements_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ArrayExpr::_internal_mutable_elements() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.elements_;
}

// bool multidims = 6 [json_name = "multidims"];
inline void ArrayExpr::clear_multidims() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.multidims_ = false;
}
inline bool ArrayExpr::multidims() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.multidims)
  return _internal_multidims();
}
inline void ArrayExpr::set_multidims(bool value) {
  _internal_set_multidims(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.multidims)
}
inline bool ArrayExpr::_internal_multidims() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.multidims_;
}
inline void ArrayExpr::_internal_set_multidims(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.multidims_ = value;
}

// int32 location = 7 [json_name = "location"];
inline void ArrayExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t ArrayExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.location)
  return _internal_location();
}
inline void ArrayExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.location)
}
inline ::int32_t ArrayExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void ArrayExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// RowExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool RowExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void RowExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& RowExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RowExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RowExpr.xpr)
  return _internal_xpr();
}
inline void RowExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RowExpr.xpr)
}
inline ::pg_query::Node* RowExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RowExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RowExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RowExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* RowExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.RowExpr.xpr)
  return _msg;
}
inline void RowExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_args().size();
}
inline int RowExpr::args_size() const {
  return _internal_args_size();
}
inline void RowExpr::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* RowExpr::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RowExpr.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RowExpr::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowExpr.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& RowExpr::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RowExpr.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* RowExpr::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RowExpr.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RowExpr::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RowExpr.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RowExpr::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RowExpr::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// uint32 row_typeid = 3 [json_name = "row_typeid"];
inline void RowExpr::clear_row_typeid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.row_typeid_ = 0u;
}
inline ::uint32_t RowExpr::row_typeid() const {
  // @@protoc_insertion_point(field_get:pg_query.RowExpr.row_typeid)
  return _internal_row_typeid();
}
inline void RowExpr::set_row_typeid(::uint32_t value) {
  _internal_set_row_typeid(value);
  // @@protoc_insertion_point(field_set:pg_query.RowExpr.row_typeid)
}
inline ::uint32_t RowExpr::_internal_row_typeid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.row_typeid_;
}
inline void RowExpr::_internal_set_row_typeid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.row_typeid_ = value;
}

// .pg_query.CoercionForm row_format = 4 [json_name = "row_format"];
inline void RowExpr::clear_row_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.row_format_ = 0;
}
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::set_row_format(::pg_query::CoercionForm value) {
  _internal_set_row_format(value);
  // @@protoc_insertion_point(field_set:pg_query.RowExpr.row_format)
}
inline ::pg_query::CoercionForm RowExpr::_internal_row_format() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CoercionForm>(_impl_.row_format_);
}
inline void RowExpr::_internal_set_row_format(::pg_query::CoercionForm value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.row_format_ = value;
}

// repeated .pg_query.Node colnames = 5 [json_name = "colnames"];
inline int RowExpr::_internal_colnames_size() const {
  return _internal_colnames().size();
}
inline int RowExpr::colnames_size() const {
  return _internal_colnames_size();
}
inline void RowExpr::clear_colnames() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.colnames_.Clear();
}
inline ::pg_query::Node* RowExpr::mutable_colnames(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RowExpr.colnames)
  return _internal_mutable_colnames()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RowExpr::mutable_colnames()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowExpr.colnames)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_colnames();
}
inline const ::pg_query::Node& RowExpr::colnames(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RowExpr.colnames)
  return _internal_colnames().Get(index);
}
inline ::pg_query::Node* RowExpr::add_colnames() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_colnames()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RowExpr.colnames)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RowExpr::colnames() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RowExpr.colnames)
  return _internal_colnames();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RowExpr::_internal_colnames() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.colnames_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RowExpr::_internal_mutable_colnames() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.colnames_;
}

// int32 location = 6 [json_name = "location"];
inline void RowExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t RowExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RowExpr.location)
  return _internal_location();
}
inline void RowExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RowExpr.location)
}
inline ::int32_t RowExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void RowExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// RowCompareExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool RowCompareExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void RowCompareExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& RowCompareExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RowCompareExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.xpr)
  return _internal_xpr();
}
inline void RowCompareExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RowCompareExpr.xpr)
}
inline ::pg_query::Node* RowCompareExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RowCompareExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RowCompareExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RowCompareExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* RowCompareExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.xpr)
  return _msg;
}
inline void RowCompareExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RowCompareExpr.xpr)
}

// .pg_query.RowCompareType rctype = 2 [json_name = "rctype"];
inline void RowCompareExpr::clear_rctype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rctype_ = 0;
}
inline ::pg_query::RowCompareType RowCompareExpr::rctype() const {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.rctype)
  return _internal_rctype();
}
inline void RowCompareExpr::set_rctype(::pg_query::RowCompareType value) {
  _internal_set_rctype(value);
  // @@protoc_insertion_point(field_set:pg_query.RowCompareExpr.rctype)
}
inline ::pg_query::RowCompareType RowCompareExpr::_internal_rctype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::RowCompareType>(_impl_.rctype_);
}
inline void RowCompareExpr::_internal_set_rctype(::pg_query::RowCompareType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.rctype_ = value;
}

// repeated .pg_query.Node opnos = 3 [json_name = "opnos"];
inline int RowCompareExpr::_internal_opnos_size() const {
  return _internal_opnos().size();
}
inline int RowCompareExpr::opnos_size() const {
  return _internal_opnos_size();
}
inline void RowCompareExpr::clear_opnos() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opnos_.Clear();
}
inline ::pg_query::Node* RowCompareExpr::mutable_opnos(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.opnos)
  return _internal_mutable_opnos()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RowCompareExpr::mutable_opnos()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.opnos)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_opnos();
}
inline const ::pg_query::Node& RowCompareExpr::opnos(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.opnos)
  return _internal_opnos().Get(index);
}
inline ::pg_query::Node* RowCompareExpr::add_opnos() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_opnos()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.opnos)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RowCompareExpr::opnos() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.opnos)
  return _internal_opnos();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RowCompareExpr::_internal_opnos() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opnos_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RowCompareExpr::_internal_mutable_opnos() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.opnos_;
}

// repeated .pg_query.Node opfamilies = 4 [json_name = "opfamilies"];
inline int RowCompareExpr::_internal_opfamilies_size() const {
  return _internal_opfamilies().size();
}
inline int RowCompareExpr::opfamilies_size() const {
  return _internal_opfamilies_size();
}
inline void RowCompareExpr::clear_opfamilies() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opfamilies_.Clear();
}
inline ::pg_query::Node* RowCompareExpr::mutable_opfamilies(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.opfamilies)
  return _internal_mutable_opfamilies()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RowCompareExpr::mutable_opfamilies()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.opfamilies)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_opfamilies();
}
inline const ::pg_query::Node& RowCompareExpr::opfamilies(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.opfamilies)
  return _internal_opfamilies().Get(index);
}
inline ::pg_query::Node* RowCompareExpr::add_opfamilies() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_opfamilies()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.opfamilies)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RowCompareExpr::opfamilies() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.opfamilies)
  return _internal_opfamilies();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RowCompareExpr::_internal_opfamilies() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opfamilies_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RowCompareExpr::_internal_mutable_opfamilies() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.opfamilies_;
}

// repeated .pg_query.Node inputcollids = 5 [json_name = "inputcollids"];
inline int RowCompareExpr::_internal_inputcollids_size() const {
  return _internal_inputcollids().size();
}
inline int RowCompareExpr::inputcollids_size() const {
  return _internal_inputcollids_size();
}
inline void RowCompareExpr::clear_inputcollids() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inputcollids_.Clear();
}
inline ::pg_query::Node* RowCompareExpr::mutable_inputcollids(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.inputcollids)
  return _internal_mutable_inputcollids()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RowCompareExpr::mutable_inputcollids()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.inputcollids)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_inputcollids();
}
inline const ::pg_query::Node& RowCompareExpr::inputcollids(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.inputcollids)
  return _internal_inputcollids().Get(index);
}
inline ::pg_query::Node* RowCompareExpr::add_inputcollids() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_inputcollids()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.inputcollids)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RowCompareExpr::inputcollids() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.inputcollids)
  return _internal_inputcollids();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RowCompareExpr::_internal_inputcollids() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inputcollids_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RowCompareExpr::_internal_mutable_inputcollids() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.inputcollids_;
}

// repeated .pg_query.Node largs = 6 [json_name = "largs"];
inline int RowCompareExpr::_internal_largs_size() const {
  return _internal_largs().size();
}
inline int RowCompareExpr::largs_size() const {
  return _internal_largs_size();
}
inline void RowCompareExpr::clear_largs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.largs_.Clear();
}
inline ::pg_query::Node* RowCompareExpr::mutable_largs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.largs)
  return _internal_mutable_largs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RowCompareExpr::mutable_largs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.largs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_largs();
}
inline const ::pg_query::Node& RowCompareExpr::largs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.largs)
  return _internal_largs().Get(index);
}
inline ::pg_query::Node* RowCompareExpr::add_largs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_largs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.largs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RowCompareExpr::largs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.largs)
  return _internal_largs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RowCompareExpr::_internal_largs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.largs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RowCompareExpr::_internal_mutable_largs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.largs_;
}

// repeated .pg_query.Node rargs = 7 [json_name = "rargs"];
inline int RowCompareExpr::_internal_rargs_size() const {
  return _internal_rargs().size();
}
inline int RowCompareExpr::rargs_size() const {
  return _internal_rargs_size();
}
inline void RowCompareExpr::clear_rargs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rargs_.Clear();
}
inline ::pg_query::Node* RowCompareExpr::mutable_rargs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.rargs)
  return _internal_mutable_rargs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RowCompareExpr::mutable_rargs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.rargs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_rargs();
}
inline const ::pg_query::Node& RowCompareExpr::rargs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.rargs)
  return _internal_rargs().Get(index);
}
inline ::pg_query::Node* RowCompareExpr::add_rargs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_rargs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.rargs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RowCompareExpr::rargs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.rargs)
  return _internal_rargs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RowCompareExpr::_internal_rargs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.rargs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RowCompareExpr::_internal_mutable_rargs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.rargs_;
}

// -------------------------------------------------------------------

// CoalesceExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CoalesceExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void CoalesceExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CoalesceExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CoalesceExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.xpr)
  return _internal_xpr();
}
inline void CoalesceExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoalesceExpr.xpr)
}
inline ::pg_query::Node* CoalesceExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CoalesceExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CoalesceExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CoalesceExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* CoalesceExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.CoalesceExpr.xpr)
  return _msg;
}
inline void CoalesceExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CoalesceExpr.xpr)
}

// uint32 coalescetype = 2 [json_name = "coalescetype"];
inline void CoalesceExpr::clear_coalescetype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coalescetype_ = 0u;
}
inline ::uint32_t CoalesceExpr::coalescetype() const {
  // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.coalescetype)
  return _internal_coalescetype();
}
inline void CoalesceExpr::set_coalescetype(::uint32_t value) {
  _internal_set_coalescetype(value);
  // @@protoc_insertion_point(field_set:pg_query.CoalesceExpr.coalescetype)
}
inline ::uint32_t CoalesceExpr::_internal_coalescetype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.coalescetype_;
}
inline void CoalesceExpr::_internal_set_coalescetype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.coalescetype_ = value;
}

// uint32 coalescecollid = 3 [json_name = "coalescecollid"];
inline void CoalesceExpr::clear_coalescecollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coalescecollid_ = 0u;
}
inline ::uint32_t CoalesceExpr::coalescecollid() const {
  // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.coalescecollid)
  return _internal_coalescecollid();
}
inline void CoalesceExpr::set_coalescecollid(::uint32_t value) {
  _internal_set_coalescecollid(value);
  // @@protoc_insertion_point(field_set:pg_query.CoalesceExpr.coalescecollid)
}
inline ::uint32_t CoalesceExpr::_internal_coalescecollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.coalescecollid_;
}
inline void CoalesceExpr::_internal_set_coalescecollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.coalescecollid_ = value;
}

// repeated .pg_query.Node args = 4 [json_name = "args"];
inline int CoalesceExpr::_internal_args_size() const {
  return _internal_args().size();
}
inline int CoalesceExpr::args_size() const {
  return _internal_args_size();
}
inline void CoalesceExpr::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* CoalesceExpr::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CoalesceExpr.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CoalesceExpr::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CoalesceExpr.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& CoalesceExpr::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* CoalesceExpr::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CoalesceExpr.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CoalesceExpr::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CoalesceExpr.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CoalesceExpr::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CoalesceExpr::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// int32 location = 5 [json_name = "location"];
inline void CoalesceExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t CoalesceExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.location)
  return _internal_location();
}
inline void CoalesceExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CoalesceExpr.location)
}
inline ::int32_t CoalesceExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void CoalesceExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// MinMaxExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool MinMaxExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void MinMaxExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& MinMaxExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& MinMaxExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.xpr)
  return _internal_xpr();
}
inline void MinMaxExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MinMaxExpr.xpr)
}
inline ::pg_query::Node* MinMaxExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* MinMaxExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.MinMaxExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* MinMaxExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* MinMaxExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.MinMaxExpr.xpr)
  return _msg;
}
inline void MinMaxExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.MinMaxExpr.xpr)
}

// uint32 minmaxtype = 2 [json_name = "minmaxtype"];
inline void MinMaxExpr::clear_minmaxtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.minmaxtype_ = 0u;
}
inline ::uint32_t MinMaxExpr::minmaxtype() const {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.minmaxtype)
  return _internal_minmaxtype();
}
inline void MinMaxExpr::set_minmaxtype(::uint32_t value) {
  _internal_set_minmaxtype(value);
  // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.minmaxtype)
}
inline ::uint32_t MinMaxExpr::_internal_minmaxtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.minmaxtype_;
}
inline void MinMaxExpr::_internal_set_minmaxtype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.minmaxtype_ = value;
}

// uint32 minmaxcollid = 3 [json_name = "minmaxcollid"];
inline void MinMaxExpr::clear_minmaxcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.minmaxcollid_ = 0u;
}
inline ::uint32_t MinMaxExpr::minmaxcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.minmaxcollid)
  return _internal_minmaxcollid();
}
inline void MinMaxExpr::set_minmaxcollid(::uint32_t value) {
  _internal_set_minmaxcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.minmaxcollid)
}
inline ::uint32_t MinMaxExpr::_internal_minmaxcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.minmaxcollid_;
}
inline void MinMaxExpr::_internal_set_minmaxcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.minmaxcollid_ = value;
}

// uint32 inputcollid = 4 [json_name = "inputcollid"];
inline void MinMaxExpr::clear_inputcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inputcollid_ = 0u;
}
inline ::uint32_t MinMaxExpr::inputcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.inputcollid)
  return _internal_inputcollid();
}
inline void MinMaxExpr::set_inputcollid(::uint32_t value) {
  _internal_set_inputcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.inputcollid)
}
inline ::uint32_t MinMaxExpr::_internal_inputcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inputcollid_;
}
inline void MinMaxExpr::_internal_set_inputcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inputcollid_ = value;
}

// .pg_query.MinMaxOp op = 5 [json_name = "op"];
inline void MinMaxExpr::clear_op() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.op_ = 0;
}
inline ::pg_query::MinMaxOp MinMaxExpr::op() const {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.op)
  return _internal_op();
}
inline void MinMaxExpr::set_op(::pg_query::MinMaxOp value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.op)
}
inline ::pg_query::MinMaxOp MinMaxExpr::_internal_op() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::MinMaxOp>(_impl_.op_);
}
inline void MinMaxExpr::_internal_set_op(::pg_query::MinMaxOp value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.op_ = value;
}

// repeated .pg_query.Node args = 6 [json_name = "args"];
inline int MinMaxExpr::_internal_args_size() const {
  return _internal_args().size();
}
inline int MinMaxExpr::args_size() const {
  return _internal_args_size();
}
inline void MinMaxExpr::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* MinMaxExpr::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.MinMaxExpr.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* MinMaxExpr::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.MinMaxExpr.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& MinMaxExpr::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* MinMaxExpr::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.MinMaxExpr.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& MinMaxExpr::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.MinMaxExpr.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
MinMaxExpr::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
MinMaxExpr::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// int32 location = 7 [json_name = "location"];
inline void MinMaxExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t MinMaxExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.location)
  return _internal_location();
}
inline void MinMaxExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.location)
}
inline ::int32_t MinMaxExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void MinMaxExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// SQLValueFunction

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool SQLValueFunction::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void SQLValueFunction::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& SQLValueFunction::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SQLValueFunction::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.xpr)
  return _internal_xpr();
}
inline void SQLValueFunction::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SQLValueFunction.xpr)
}
inline ::pg_query::Node* SQLValueFunction::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SQLValueFunction::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SQLValueFunction.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SQLValueFunction::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* SQLValueFunction::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.SQLValueFunction.xpr)
  return _msg;
}
inline void SQLValueFunction::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SQLValueFunction.xpr)
}

// .pg_query.SQLValueFunctionOp op = 2 [json_name = "op"];
inline void SQLValueFunction::clear_op() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.op_ = 0;
}
inline ::pg_query::SQLValueFunctionOp SQLValueFunction::op() const {
  // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.op)
  return _internal_op();
}
inline void SQLValueFunction::set_op(::pg_query::SQLValueFunctionOp value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:pg_query.SQLValueFunction.op)
}
inline ::pg_query::SQLValueFunctionOp SQLValueFunction::_internal_op() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::SQLValueFunctionOp>(_impl_.op_);
}
inline void SQLValueFunction::_internal_set_op(::pg_query::SQLValueFunctionOp value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.op_ = value;
}

// uint32 type = 3 [json_name = "type"];
inline void SQLValueFunction::clear_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_ = 0u;
}
inline ::uint32_t SQLValueFunction::type() const {
  // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.type)
  return _internal_type();
}
inline void SQLValueFunction::set_type(::uint32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:pg_query.SQLValueFunction.type)
}
inline ::uint32_t SQLValueFunction::_internal_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_;
}
inline void SQLValueFunction::_internal_set_type(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_ = value;
}

// int32 typmod = 4 [json_name = "typmod"];
inline void SQLValueFunction::clear_typmod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.typmod_ = 0;
}
inline ::int32_t SQLValueFunction::typmod() const {
  // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.typmod)
  return _internal_typmod();
}
inline void SQLValueFunction::set_typmod(::int32_t value) {
  _internal_set_typmod(value);
  // @@protoc_insertion_point(field_set:pg_query.SQLValueFunction.typmod)
}
inline ::int32_t SQLValueFunction::_internal_typmod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.typmod_;
}
inline void SQLValueFunction::_internal_set_typmod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.typmod_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void SQLValueFunction::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t SQLValueFunction::location() const {
  // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.location)
  return _internal_location();
}
inline void SQLValueFunction::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.SQLValueFunction.location)
}
inline ::int32_t SQLValueFunction::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void SQLValueFunction::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// XmlExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool XmlExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void XmlExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& XmlExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& XmlExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.xpr)
  return _internal_xpr();
}
inline void XmlExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.XmlExpr.xpr)
}
inline ::pg_query::Node* XmlExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* XmlExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.XmlExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* XmlExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* XmlExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.xpr)
  return _msg;
}
inline void XmlExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.XmlExpr.xpr)
}

// .pg_query.XmlExprOp op = 2 [json_name = "op"];
inline void XmlExpr::clear_op() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.op_ = 0;
}
inline ::pg_query::XmlExprOp XmlExpr::op() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.op)
  return _internal_op();
}
inline void XmlExpr::set_op(::pg_query::XmlExprOp value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.op)
}
inline ::pg_query::XmlExprOp XmlExpr::_internal_op() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::XmlExprOp>(_impl_.op_);
}
inline void XmlExpr::_internal_set_op(::pg_query::XmlExprOp value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.op_ = value;
}

// string name = 3 [json_name = "name"];
inline void XmlExpr::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& XmlExpr::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void XmlExpr::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.name)
}
inline std::string* XmlExpr::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.name)
  return _s;
}
inline const std::string& XmlExpr::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void XmlExpr::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* XmlExpr::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* XmlExpr::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.XmlExpr.name)
  return _impl_.name_.Release();
}
inline void XmlExpr::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_named_args().size();
}
inline int XmlExpr::named_args_size() const {
  return _internal_named_args_size();
}
inline void XmlExpr::clear_named_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.named_args_.Clear();
}
inline ::pg_query::Node* XmlExpr::mutable_named_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.named_args)
  return _internal_mutable_named_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* XmlExpr::mutable_named_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.XmlExpr.named_args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_named_args();
}
inline const ::pg_query::Node& XmlExpr::named_args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.named_args)
  return _internal_named_args().Get(index);
}
inline ::pg_query::Node* XmlExpr::add_named_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_named_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.XmlExpr.named_args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& XmlExpr::named_args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.XmlExpr.named_args)
  return _internal_named_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
XmlExpr::_internal_named_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.named_args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
XmlExpr::_internal_mutable_named_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.named_args_;
}

// repeated .pg_query.Node arg_names = 5 [json_name = "arg_names"];
inline int XmlExpr::_internal_arg_names_size() const {
  return _internal_arg_names().size();
}
inline int XmlExpr::arg_names_size() const {
  return _internal_arg_names_size();
}
inline void XmlExpr::clear_arg_names() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.arg_names_.Clear();
}
inline ::pg_query::Node* XmlExpr::mutable_arg_names(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.arg_names)
  return _internal_mutable_arg_names()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* XmlExpr::mutable_arg_names()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.XmlExpr.arg_names)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_arg_names();
}
inline const ::pg_query::Node& XmlExpr::arg_names(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.arg_names)
  return _internal_arg_names().Get(index);
}
inline ::pg_query::Node* XmlExpr::add_arg_names() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_arg_names()->Add();
  // @@protoc_insertion_point(field_add:pg_query.XmlExpr.arg_names)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& XmlExpr::arg_names() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.XmlExpr.arg_names)
  return _internal_arg_names();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
XmlExpr::_internal_arg_names() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.arg_names_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
XmlExpr::_internal_mutable_arg_names() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.arg_names_;
}

// repeated .pg_query.Node args = 6 [json_name = "args"];
inline int XmlExpr::_internal_args_size() const {
  return _internal_args().size();
}
inline int XmlExpr::args_size() const {
  return _internal_args_size();
}
inline void XmlExpr::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* XmlExpr::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* XmlExpr::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.XmlExpr.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& XmlExpr::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* XmlExpr::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.XmlExpr.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& XmlExpr::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.XmlExpr.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
XmlExpr::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
XmlExpr::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// .pg_query.XmlOptionType xmloption = 7 [json_name = "xmloption"];
inline void XmlExpr::clear_xmloption() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.xmloption_ = 0;
}
inline ::pg_query::XmlOptionType XmlExpr::xmloption() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.xmloption)
  return _internal_xmloption();
}
inline void XmlExpr::set_xmloption(::pg_query::XmlOptionType value) {
  _internal_set_xmloption(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.xmloption)
}
inline ::pg_query::XmlOptionType XmlExpr::_internal_xmloption() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::XmlOptionType>(_impl_.xmloption_);
}
inline void XmlExpr::_internal_set_xmloption(::pg_query::XmlOptionType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.xmloption_ = value;
}

// bool indent = 8 [json_name = "indent"];
inline void XmlExpr::clear_indent() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indent_ = false;
}
inline bool XmlExpr::indent() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.indent)
  return _internal_indent();
}
inline void XmlExpr::set_indent(bool value) {
  _internal_set_indent(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.indent)
}
inline bool XmlExpr::_internal_indent() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.indent_;
}
inline void XmlExpr::_internal_set_indent(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.indent_ = value;
}

// uint32 type = 9 [json_name = "type"];
inline void XmlExpr::clear_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_ = 0u;
}
inline ::uint32_t XmlExpr::type() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.type)
  return _internal_type();
}
inline void XmlExpr::set_type(::uint32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.type)
}
inline ::uint32_t XmlExpr::_internal_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_;
}
inline void XmlExpr::_internal_set_type(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_ = value;
}

// int32 typmod = 10 [json_name = "typmod"];
inline void XmlExpr::clear_typmod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.typmod_ = 0;
}
inline ::int32_t XmlExpr::typmod() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.typmod)
  return _internal_typmod();
}
inline void XmlExpr::set_typmod(::int32_t value) {
  _internal_set_typmod(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.typmod)
}
inline ::int32_t XmlExpr::_internal_typmod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.typmod_;
}
inline void XmlExpr::_internal_set_typmod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.typmod_ = value;
}

// int32 location = 11 [json_name = "location"];
inline void XmlExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t XmlExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlExpr.location)
  return _internal_location();
}
inline void XmlExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlExpr.location)
}
inline ::int32_t XmlExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void XmlExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// JsonFormat

// .pg_query.JsonFormatType format_type = 1 [json_name = "format_type"];
inline void JsonFormat::clear_format_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.format_type_ = 0;
}
inline ::pg_query::JsonFormatType JsonFormat::format_type() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonFormat.format_type)
  return _internal_format_type();
}
inline void JsonFormat::set_format_type(::pg_query::JsonFormatType value) {
  _internal_set_format_type(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonFormat.format_type)
}
inline ::pg_query::JsonFormatType JsonFormat::_internal_format_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::JsonFormatType>(_impl_.format_type_);
}
inline void JsonFormat::_internal_set_format_type(::pg_query::JsonFormatType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.format_type_ = value;
}

// .pg_query.JsonEncoding encoding = 2 [json_name = "encoding"];
inline void JsonFormat::clear_encoding() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.encoding_ = 0;
}
inline ::pg_query::JsonEncoding JsonFormat::encoding() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonFormat.encoding)
  return _internal_encoding();
}
inline void JsonFormat::set_encoding(::pg_query::JsonEncoding value) {
  _internal_set_encoding(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonFormat.encoding)
}
inline ::pg_query::JsonEncoding JsonFormat::_internal_encoding() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::JsonEncoding>(_impl_.encoding_);
}
inline void JsonFormat::_internal_set_encoding(::pg_query::JsonEncoding value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.encoding_ = value;
}

// int32 location = 3 [json_name = "location"];
inline void JsonFormat::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t JsonFormat::location() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonFormat.location)
  return _internal_location();
}
inline void JsonFormat::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonFormat.location)
}
inline ::int32_t JsonFormat::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void JsonFormat::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// JsonReturning

// .pg_query.JsonFormat format = 1 [json_name = "format"];
inline bool JsonReturning::has_format() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.format_ != nullptr);
  return value;
}
inline void JsonReturning::clear_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.format_ != nullptr) _impl_.format_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::JsonFormat& JsonReturning::_internal_format() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonFormat* p = _impl_.format_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonFormat&>(::pg_query::_JsonFormat_default_instance_);
}
inline const ::pg_query::JsonFormat& JsonReturning::format() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonReturning.format)
  return _internal_format();
}
inline void JsonReturning::unsafe_arena_set_allocated_format(::pg_query::JsonFormat* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.format_);
  }
  _impl_.format_ = reinterpret_cast<::pg_query::JsonFormat*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonReturning.format)
}
inline ::pg_query::JsonFormat* JsonReturning::release_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::JsonFormat* released = _impl_.format_;
  _impl_.format_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonFormat* JsonReturning::unsafe_arena_release_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonReturning.format)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::JsonFormat* temp = _impl_.format_;
  _impl_.format_ = nullptr;
  return temp;
}
inline ::pg_query::JsonFormat* JsonReturning::_internal_mutable_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.format_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonFormat>(GetArena());
    _impl_.format_ = reinterpret_cast<::pg_query::JsonFormat*>(p);
  }
  return _impl_.format_;
}
inline ::pg_query::JsonFormat* JsonReturning::mutable_format() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonFormat* _msg = _internal_mutable_format();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonReturning.format)
  return _msg;
}
inline void JsonReturning::set_allocated_format(::pg_query::JsonFormat* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonFormat*>(_impl_.format_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonFormat*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.format_ = reinterpret_cast<::pg_query::JsonFormat*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonReturning.format)
}

// uint32 typid = 2 [json_name = "typid"];
inline void JsonReturning::clear_typid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.typid_ = 0u;
}
inline ::uint32_t JsonReturning::typid() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonReturning.typid)
  return _internal_typid();
}
inline void JsonReturning::set_typid(::uint32_t value) {
  _internal_set_typid(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonReturning.typid)
}
inline ::uint32_t JsonReturning::_internal_typid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.typid_;
}
inline void JsonReturning::_internal_set_typid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.typid_ = value;
}

// int32 typmod = 3 [json_name = "typmod"];
inline void JsonReturning::clear_typmod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.typmod_ = 0;
}
inline ::int32_t JsonReturning::typmod() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonReturning.typmod)
  return _internal_typmod();
}
inline void JsonReturning::set_typmod(::int32_t value) {
  _internal_set_typmod(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonReturning.typmod)
}
inline ::int32_t JsonReturning::_internal_typmod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.typmod_;
}
inline void JsonReturning::_internal_set_typmod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.typmod_ = value;
}

// -------------------------------------------------------------------

// JsonValueExpr

// .pg_query.Node raw_expr = 1 [json_name = "raw_expr"];
inline bool JsonValueExpr::has_raw_expr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.raw_expr_ != nullptr);
  return value;
}
inline void JsonValueExpr::clear_raw_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.raw_expr_ != nullptr) _impl_.raw_expr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& JsonValueExpr::_internal_raw_expr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.raw_expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JsonValueExpr::raw_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonValueExpr.raw_expr)
  return _internal_raw_expr();
}
inline void JsonValueExpr::unsafe_arena_set_allocated_raw_expr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.raw_expr_);
  }
  _impl_.raw_expr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonValueExpr.raw_expr)
}
inline ::pg_query::Node* JsonValueExpr::release_raw_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.raw_expr_;
  _impl_.raw_expr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* JsonValueExpr::unsafe_arena_release_raw_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonValueExpr.raw_expr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.raw_expr_;
  _impl_.raw_expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JsonValueExpr::_internal_mutable_raw_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.raw_expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.raw_expr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.raw_expr_;
}
inline ::pg_query::Node* JsonValueExpr::mutable_raw_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_raw_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonValueExpr.raw_expr)
  return _msg;
}
inline void JsonValueExpr::set_allocated_raw_expr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.raw_expr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.raw_expr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonValueExpr.raw_expr)
}

// .pg_query.Node formatted_expr = 2 [json_name = "formatted_expr"];
inline bool JsonValueExpr::has_formatted_expr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.formatted_expr_ != nullptr);
  return value;
}
inline void JsonValueExpr::clear_formatted_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.formatted_expr_ != nullptr) _impl_.formatted_expr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& JsonValueExpr::_internal_formatted_expr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.formatted_expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JsonValueExpr::formatted_expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonValueExpr.formatted_expr)
  return _internal_formatted_expr();
}
inline void JsonValueExpr::unsafe_arena_set_allocated_formatted_expr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.formatted_expr_);
  }
  _impl_.formatted_expr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonValueExpr.formatted_expr)
}
inline ::pg_query::Node* JsonValueExpr::release_formatted_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.formatted_expr_;
  _impl_.formatted_expr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* JsonValueExpr::unsafe_arena_release_formatted_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonValueExpr.formatted_expr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.formatted_expr_;
  _impl_.formatted_expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JsonValueExpr::_internal_mutable_formatted_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.formatted_expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.formatted_expr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.formatted_expr_;
}
inline ::pg_query::Node* JsonValueExpr::mutable_formatted_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_formatted_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonValueExpr.formatted_expr)
  return _msg;
}
inline void JsonValueExpr::set_allocated_formatted_expr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.formatted_expr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.formatted_expr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonValueExpr.formatted_expr)
}

// .pg_query.JsonFormat format = 3 [json_name = "format"];
inline bool JsonValueExpr::has_format() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.format_ != nullptr);
  return value;
}
inline void JsonValueExpr::clear_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.format_ != nullptr) _impl_.format_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::JsonFormat& JsonValueExpr::_internal_format() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonFormat* p = _impl_.format_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonFormat&>(::pg_query::_JsonFormat_default_instance_);
}
inline const ::pg_query::JsonFormat& JsonValueExpr::format() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonValueExpr.format)
  return _internal_format();
}
inline void JsonValueExpr::unsafe_arena_set_allocated_format(::pg_query::JsonFormat* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.format_);
  }
  _impl_.format_ = reinterpret_cast<::pg_query::JsonFormat*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonValueExpr.format)
}
inline ::pg_query::JsonFormat* JsonValueExpr::release_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::JsonFormat* released = _impl_.format_;
  _impl_.format_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonFormat* JsonValueExpr::unsafe_arena_release_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonValueExpr.format)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::JsonFormat* temp = _impl_.format_;
  _impl_.format_ = nullptr;
  return temp;
}
inline ::pg_query::JsonFormat* JsonValueExpr::_internal_mutable_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.format_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonFormat>(GetArena());
    _impl_.format_ = reinterpret_cast<::pg_query::JsonFormat*>(p);
  }
  return _impl_.format_;
}
inline ::pg_query::JsonFormat* JsonValueExpr::mutable_format() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonFormat* _msg = _internal_mutable_format();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonValueExpr.format)
  return _msg;
}
inline void JsonValueExpr::set_allocated_format(::pg_query::JsonFormat* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonFormat*>(_impl_.format_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonFormat*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.format_ = reinterpret_cast<::pg_query::JsonFormat*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonValueExpr.format)
}

// -------------------------------------------------------------------

// JsonConstructorExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool JsonConstructorExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void JsonConstructorExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& JsonConstructorExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JsonConstructorExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonConstructorExpr.xpr)
  return _internal_xpr();
}
inline void JsonConstructorExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonConstructorExpr.xpr)
}
inline ::pg_query::Node* JsonConstructorExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* JsonConstructorExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonConstructorExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JsonConstructorExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* JsonConstructorExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonConstructorExpr.xpr)
  return _msg;
}
inline void JsonConstructorExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonConstructorExpr.xpr)
}

// .pg_query.JsonConstructorType type = 2 [json_name = "type"];
inline void JsonConstructorExpr::clear_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_ = 0;
}
inline ::pg_query::JsonConstructorType JsonConstructorExpr::type() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonConstructorExpr.type)
  return _internal_type();
}
inline void JsonConstructorExpr::set_type(::pg_query::JsonConstructorType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonConstructorExpr.type)
}
inline ::pg_query::JsonConstructorType JsonConstructorExpr::_internal_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::JsonConstructorType>(_impl_.type_);
}
inline void JsonConstructorExpr::_internal_set_type(::pg_query::JsonConstructorType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_ = value;
}

// repeated .pg_query.Node args = 3 [json_name = "args"];
inline int JsonConstructorExpr::_internal_args_size() const {
  return _internal_args().size();
}
inline int JsonConstructorExpr::args_size() const {
  return _internal_args_size();
}
inline void JsonConstructorExpr::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* JsonConstructorExpr::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.JsonConstructorExpr.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* JsonConstructorExpr::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.JsonConstructorExpr.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& JsonConstructorExpr::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonConstructorExpr.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* JsonConstructorExpr::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.JsonConstructorExpr.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& JsonConstructorExpr::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.JsonConstructorExpr.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
JsonConstructorExpr::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
JsonConstructorExpr::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// .pg_query.Node func = 4 [json_name = "func"];
inline bool JsonConstructorExpr::has_func() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.func_ != nullptr);
  return value;
}
inline void JsonConstructorExpr::clear_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.func_ != nullptr) _impl_.func_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& JsonConstructorExpr::_internal_func() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.func_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JsonConstructorExpr::func() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonConstructorExpr.func)
  return _internal_func();
}
inline void JsonConstructorExpr::unsafe_arena_set_allocated_func(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.func_);
  }
  _impl_.func_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonConstructorExpr.func)
}
inline ::pg_query::Node* JsonConstructorExpr::release_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.func_;
  _impl_.func_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* JsonConstructorExpr::unsafe_arena_release_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonConstructorExpr.func)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.func_;
  _impl_.func_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JsonConstructorExpr::_internal_mutable_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.func_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.func_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.func_;
}
inline ::pg_query::Node* JsonConstructorExpr::mutable_func() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_func();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonConstructorExpr.func)
  return _msg;
}
inline void JsonConstructorExpr::set_allocated_func(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.func_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.func_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonConstructorExpr.func)
}

// .pg_query.Node coercion = 5 [json_name = "coercion"];
inline bool JsonConstructorExpr::has_coercion() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.coercion_ != nullptr);
  return value;
}
inline void JsonConstructorExpr::clear_coercion() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.coercion_ != nullptr) _impl_.coercion_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& JsonConstructorExpr::_internal_coercion() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.coercion_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JsonConstructorExpr::coercion() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonConstructorExpr.coercion)
  return _internal_coercion();
}
inline void JsonConstructorExpr::unsafe_arena_set_allocated_coercion(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.coercion_);
  }
  _impl_.coercion_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonConstructorExpr.coercion)
}
inline ::pg_query::Node* JsonConstructorExpr::release_coercion() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.coercion_;
  _impl_.coercion_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* JsonConstructorExpr::unsafe_arena_release_coercion() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonConstructorExpr.coercion)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.coercion_;
  _impl_.coercion_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JsonConstructorExpr::_internal_mutable_coercion() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.coercion_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.coercion_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.coercion_;
}
inline ::pg_query::Node* JsonConstructorExpr::mutable_coercion() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_coercion();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonConstructorExpr.coercion)
  return _msg;
}
inline void JsonConstructorExpr::set_allocated_coercion(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.coercion_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.coercion_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonConstructorExpr.coercion)
}

// .pg_query.JsonReturning returning = 6 [json_name = "returning"];
inline bool JsonConstructorExpr::has_returning() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.returning_ != nullptr);
  return value;
}
inline void JsonConstructorExpr::clear_returning() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.returning_ != nullptr) _impl_.returning_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::pg_query::JsonReturning& JsonConstructorExpr::_internal_returning() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonReturning* p = _impl_.returning_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonReturning&>(::pg_query::_JsonReturning_default_instance_);
}
inline const ::pg_query::JsonReturning& JsonConstructorExpr::returning() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonConstructorExpr.returning)
  return _internal_returning();
}
inline void JsonConstructorExpr::unsafe_arena_set_allocated_returning(::pg_query::JsonReturning* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.returning_);
  }
  _impl_.returning_ = reinterpret_cast<::pg_query::JsonReturning*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonConstructorExpr.returning)
}
inline ::pg_query::JsonReturning* JsonConstructorExpr::release_returning() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::JsonReturning* released = _impl_.returning_;
  _impl_.returning_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonReturning* JsonConstructorExpr::unsafe_arena_release_returning() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonConstructorExpr.returning)

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::JsonReturning* temp = _impl_.returning_;
  _impl_.returning_ = nullptr;
  return temp;
}
inline ::pg_query::JsonReturning* JsonConstructorExpr::_internal_mutable_returning() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.returning_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonReturning>(GetArena());
    _impl_.returning_ = reinterpret_cast<::pg_query::JsonReturning*>(p);
  }
  return _impl_.returning_;
}
inline ::pg_query::JsonReturning* JsonConstructorExpr::mutable_returning() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonReturning* _msg = _internal_mutable_returning();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonConstructorExpr.returning)
  return _msg;
}
inline void JsonConstructorExpr::set_allocated_returning(::pg_query::JsonReturning* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonReturning*>(_impl_.returning_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonReturning*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }

  _impl_.returning_ = reinterpret_cast<::pg_query::JsonReturning*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonConstructorExpr.returning)
}

// bool absent_on_null = 7 [json_name = "absent_on_null"];
inline void JsonConstructorExpr::clear_absent_on_null() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.absent_on_null_ = false;
}
inline bool JsonConstructorExpr::absent_on_null() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonConstructorExpr.absent_on_null)
  return _internal_absent_on_null();
}
inline void JsonConstructorExpr::set_absent_on_null(bool value) {
  _internal_set_absent_on_null(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonConstructorExpr.absent_on_null)
}
inline bool JsonConstructorExpr::_internal_absent_on_null() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.absent_on_null_;
}
inline void JsonConstructorExpr::_internal_set_absent_on_null(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.absent_on_null_ = value;
}

// bool unique = 8 [json_name = "unique"];
inline void JsonConstructorExpr::clear_unique() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.unique_ = false;
}
inline bool JsonConstructorExpr::unique() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonConstructorExpr.unique)
  return _internal_unique();
}
inline void JsonConstructorExpr::set_unique(bool value) {
  _internal_set_unique(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonConstructorExpr.unique)
}
inline bool JsonConstructorExpr::_internal_unique() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.unique_;
}
inline void JsonConstructorExpr::_internal_set_unique(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.unique_ = value;
}

// int32 location = 9 [json_name = "location"];
inline void JsonConstructorExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t JsonConstructorExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonConstructorExpr.location)
  return _internal_location();
}
inline void JsonConstructorExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonConstructorExpr.location)
}
inline ::int32_t JsonConstructorExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void JsonConstructorExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// JsonIsPredicate

// .pg_query.Node expr = 1 [json_name = "expr"];
inline bool JsonIsPredicate::has_expr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.expr_ != nullptr);
  return value;
}
inline void JsonIsPredicate::clear_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.expr_ != nullptr) _impl_.expr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& JsonIsPredicate::_internal_expr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JsonIsPredicate::expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonIsPredicate.expr)
  return _internal_expr();
}
inline void JsonIsPredicate::unsafe_arena_set_allocated_expr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.expr_);
  }
  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonIsPredicate.expr)
}
inline ::pg_query::Node* JsonIsPredicate::release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.expr_;
  _impl_.expr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* JsonIsPredicate::unsafe_arena_release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonIsPredicate.expr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.expr_;
  _impl_.expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JsonIsPredicate::_internal_mutable_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.expr_;
}
inline ::pg_query::Node* JsonIsPredicate::mutable_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonIsPredicate.expr)
  return _msg;
}
inline void JsonIsPredicate::set_allocated_expr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.expr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonIsPredicate.expr)
}

// .pg_query.JsonFormat format = 2 [json_name = "format"];
inline bool JsonIsPredicate::has_format() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.format_ != nullptr);
  return value;
}
inline void JsonIsPredicate::clear_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.format_ != nullptr) _impl_.format_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::JsonFormat& JsonIsPredicate::_internal_format() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonFormat* p = _impl_.format_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonFormat&>(::pg_query::_JsonFormat_default_instance_);
}
inline const ::pg_query::JsonFormat& JsonIsPredicate::format() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonIsPredicate.format)
  return _internal_format();
}
inline void JsonIsPredicate::unsafe_arena_set_allocated_format(::pg_query::JsonFormat* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.format_);
  }
  _impl_.format_ = reinterpret_cast<::pg_query::JsonFormat*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonIsPredicate.format)
}
inline ::pg_query::JsonFormat* JsonIsPredicate::release_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::JsonFormat* released = _impl_.format_;
  _impl_.format_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonFormat* JsonIsPredicate::unsafe_arena_release_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonIsPredicate.format)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::JsonFormat* temp = _impl_.format_;
  _impl_.format_ = nullptr;
  return temp;
}
inline ::pg_query::JsonFormat* JsonIsPredicate::_internal_mutable_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.format_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonFormat>(GetArena());
    _impl_.format_ = reinterpret_cast<::pg_query::JsonFormat*>(p);
  }
  return _impl_.format_;
}
inline ::pg_query::JsonFormat* JsonIsPredicate::mutable_format() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonFormat* _msg = _internal_mutable_format();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonIsPredicate.format)
  return _msg;
}
inline void JsonIsPredicate::set_allocated_format(::pg_query::JsonFormat* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonFormat*>(_impl_.format_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonFormat*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.format_ = reinterpret_cast<::pg_query::JsonFormat*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonIsPredicate.format)
}

// .pg_query.JsonValueType item_type = 3 [json_name = "item_type"];
inline void JsonIsPredicate::clear_item_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.item_type_ = 0;
}
inline ::pg_query::JsonValueType JsonIsPredicate::item_type() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonIsPredicate.item_type)
  return _internal_item_type();
}
inline void JsonIsPredicate::set_item_type(::pg_query::JsonValueType value) {
  _internal_set_item_type(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonIsPredicate.item_type)
}
inline ::pg_query::JsonValueType JsonIsPredicate::_internal_item_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::JsonValueType>(_impl_.item_type_);
}
inline void JsonIsPredicate::_internal_set_item_type(::pg_query::JsonValueType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.item_type_ = value;
}

// bool unique_keys = 4 [json_name = "unique_keys"];
inline void JsonIsPredicate::clear_unique_keys() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.unique_keys_ = false;
}
inline bool JsonIsPredicate::unique_keys() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonIsPredicate.unique_keys)
  return _internal_unique_keys();
}
inline void JsonIsPredicate::set_unique_keys(bool value) {
  _internal_set_unique_keys(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonIsPredicate.unique_keys)
}
inline bool JsonIsPredicate::_internal_unique_keys() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.unique_keys_;
}
inline void JsonIsPredicate::_internal_set_unique_keys(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.unique_keys_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void JsonIsPredicate::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t JsonIsPredicate::location() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonIsPredicate.location)
  return _internal_location();
}
inline void JsonIsPredicate::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonIsPredicate.location)
}
inline ::int32_t JsonIsPredicate::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void JsonIsPredicate::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// NullTest

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool NullTest::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void NullTest::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& NullTest::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& NullTest::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.NullTest.xpr)
  return _internal_xpr();
}
inline void NullTest::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NullTest.xpr)
}
inline ::pg_query::Node* NullTest::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* NullTest::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.NullTest.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* NullTest::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* NullTest::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.NullTest.xpr)
  return _msg;
}
inline void NullTest::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.NullTest.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool NullTest::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void NullTest::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& NullTest::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& NullTest::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.NullTest.arg)
  return _internal_arg();
}
inline void NullTest::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NullTest.arg)
}
inline ::pg_query::Node* NullTest::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* NullTest::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.NullTest.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* NullTest::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* NullTest::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.NullTest.arg)
  return _msg;
}
inline void NullTest::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.NullTest.arg)
}

// .pg_query.NullTestType nulltesttype = 3 [json_name = "nulltesttype"];
inline void NullTest::clear_nulltesttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.nulltesttype_ = 0;
}
inline ::pg_query::NullTestType NullTest::nulltesttype() const {
  // @@protoc_insertion_point(field_get:pg_query.NullTest.nulltesttype)
  return _internal_nulltesttype();
}
inline void NullTest::set_nulltesttype(::pg_query::NullTestType value) {
  _internal_set_nulltesttype(value);
  // @@protoc_insertion_point(field_set:pg_query.NullTest.nulltesttype)
}
inline ::pg_query::NullTestType NullTest::_internal_nulltesttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::NullTestType>(_impl_.nulltesttype_);
}
inline void NullTest::_internal_set_nulltesttype(::pg_query::NullTestType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.nulltesttype_ = value;
}

// bool argisrow = 4 [json_name = "argisrow"];
inline void NullTest::clear_argisrow() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.argisrow_ = false;
}
inline bool NullTest::argisrow() const {
  // @@protoc_insertion_point(field_get:pg_query.NullTest.argisrow)
  return _internal_argisrow();
}
inline void NullTest::set_argisrow(bool value) {
  _internal_set_argisrow(value);
  // @@protoc_insertion_point(field_set:pg_query.NullTest.argisrow)
}
inline bool NullTest::_internal_argisrow() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.argisrow_;
}
inline void NullTest::_internal_set_argisrow(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.argisrow_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void NullTest::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t NullTest::location() const {
  // @@protoc_insertion_point(field_get:pg_query.NullTest.location)
  return _internal_location();
}
inline void NullTest::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.NullTest.location)
}
inline ::int32_t NullTest::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void NullTest::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// BooleanTest

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool BooleanTest::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void BooleanTest::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& BooleanTest::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& BooleanTest::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.BooleanTest.xpr)
  return _internal_xpr();
}
inline void BooleanTest::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.BooleanTest.xpr)
}
inline ::pg_query::Node* BooleanTest::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* BooleanTest::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.BooleanTest.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* BooleanTest::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* BooleanTest::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.BooleanTest.xpr)
  return _msg;
}
inline void BooleanTest::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.BooleanTest.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool BooleanTest::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void BooleanTest::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& BooleanTest::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& BooleanTest::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.BooleanTest.arg)
  return _internal_arg();
}
inline void BooleanTest::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.BooleanTest.arg)
}
inline ::pg_query::Node* BooleanTest::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* BooleanTest::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.BooleanTest.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* BooleanTest::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* BooleanTest::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.BooleanTest.arg)
  return _msg;
}
inline void BooleanTest::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.BooleanTest.arg)
}

// .pg_query.BoolTestType booltesttype = 3 [json_name = "booltesttype"];
inline void BooleanTest::clear_booltesttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.booltesttype_ = 0;
}
inline ::pg_query::BoolTestType BooleanTest::booltesttype() const {
  // @@protoc_insertion_point(field_get:pg_query.BooleanTest.booltesttype)
  return _internal_booltesttype();
}
inline void BooleanTest::set_booltesttype(::pg_query::BoolTestType value) {
  _internal_set_booltesttype(value);
  // @@protoc_insertion_point(field_set:pg_query.BooleanTest.booltesttype)
}
inline ::pg_query::BoolTestType BooleanTest::_internal_booltesttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::BoolTestType>(_impl_.booltesttype_);
}
inline void BooleanTest::_internal_set_booltesttype(::pg_query::BoolTestType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.booltesttype_ = value;
}

// int32 location = 4 [json_name = "location"];
inline void BooleanTest::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t BooleanTest::location() const {
  // @@protoc_insertion_point(field_get:pg_query.BooleanTest.location)
  return _internal_location();
}
inline void BooleanTest::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.BooleanTest.location)
}
inline ::int32_t BooleanTest::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void BooleanTest::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CoerceToDomain

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CoerceToDomain::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void CoerceToDomain::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CoerceToDomain::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CoerceToDomain::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.xpr)
  return _internal_xpr();
}
inline void CoerceToDomain::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceToDomain.xpr)
}
inline ::pg_query::Node* CoerceToDomain::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CoerceToDomain::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CoerceToDomain.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CoerceToDomain::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* CoerceToDomain::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.CoerceToDomain.xpr)
  return _msg;
}
inline void CoerceToDomain::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceToDomain.xpr)
}

// .pg_query.Node arg = 2 [json_name = "arg"];
inline bool CoerceToDomain::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void CoerceToDomain::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& CoerceToDomain::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CoerceToDomain::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.arg)
  return _internal_arg();
}
inline void CoerceToDomain::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceToDomain.arg)
}
inline ::pg_query::Node* CoerceToDomain::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CoerceToDomain::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CoerceToDomain.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CoerceToDomain::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* CoerceToDomain::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.CoerceToDomain.arg)
  return _msg;
}
inline void CoerceToDomain::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceToDomain.arg)
}

// uint32 resulttype = 3 [json_name = "resulttype"];
inline void CoerceToDomain::clear_resulttype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resulttype_ = 0u;
}
inline ::uint32_t CoerceToDomain::resulttype() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.resulttype)
  return _internal_resulttype();
}
inline void CoerceToDomain::set_resulttype(::uint32_t value) {
  _internal_set_resulttype(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.resulttype)
}
inline ::uint32_t CoerceToDomain::_internal_resulttype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resulttype_;
}
inline void CoerceToDomain::_internal_set_resulttype(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resulttype_ = value;
}

// int32 resulttypmod = 4 [json_name = "resulttypmod"];
inline void CoerceToDomain::clear_resulttypmod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resulttypmod_ = 0;
}
inline ::int32_t CoerceToDomain::resulttypmod() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.resulttypmod)
  return _internal_resulttypmod();
}
inline void CoerceToDomain::set_resulttypmod(::int32_t value) {
  _internal_set_resulttypmod(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.resulttypmod)
}
inline ::int32_t CoerceToDomain::_internal_resulttypmod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resulttypmod_;
}
inline void CoerceToDomain::_internal_set_resulttypmod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resulttypmod_ = value;
}

// uint32 resultcollid = 5 [json_name = "resultcollid"];
inline void CoerceToDomain::clear_resultcollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resultcollid_ = 0u;
}
inline ::uint32_t CoerceToDomain::resultcollid() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.resultcollid)
  return _internal_resultcollid();
}
inline void CoerceToDomain::set_resultcollid(::uint32_t value) {
  _internal_set_resultcollid(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.resultcollid)
}
inline ::uint32_t CoerceToDomain::_internal_resultcollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resultcollid_;
}
inline void CoerceToDomain::_internal_set_resultcollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resultcollid_ = value;
}

// .pg_query.CoercionForm coercionformat = 6 [json_name = "coercionformat"];
inline void CoerceToDomain::clear_coercionformat() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coercionformat_ = 0;
}
inline ::pg_query::CoercionForm CoerceToDomain::coercionformat() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.coercionformat)
  return _internal_coercionformat();
}
inline void CoerceToDomain::set_coercionformat(::pg_query::CoercionForm value) {
  _internal_set_coercionformat(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.coercionformat)
}
inline ::pg_query::CoercionForm CoerceToDomain::_internal_coercionformat() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CoercionForm>(_impl_.coercionformat_);
}
inline void CoerceToDomain::_internal_set_coercionformat(::pg_query::CoercionForm value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.coercionformat_ = value;
}

// int32 location = 7 [json_name = "location"];
inline void CoerceToDomain::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t CoerceToDomain::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.location)
  return _internal_location();
}
inline void CoerceToDomain::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.location)
}
inline ::int32_t CoerceToDomain::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void CoerceToDomain::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CoerceToDomainValue

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CoerceToDomainValue::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void CoerceToDomainValue::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CoerceToDomainValue::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CoerceToDomainValue::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.xpr)
  return _internal_xpr();
}
inline void CoerceToDomainValue::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceToDomainValue.xpr)
}
inline ::pg_query::Node* CoerceToDomainValue::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CoerceToDomainValue::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CoerceToDomainValue.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CoerceToDomainValue::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* CoerceToDomainValue::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.CoerceToDomainValue.xpr)
  return _msg;
}
inline void CoerceToDomainValue::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceToDomainValue.xpr)
}

// uint32 type_id = 2 [json_name = "typeId"];
inline void CoerceToDomainValue::clear_type_id() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_id_ = 0u;
}
inline ::uint32_t CoerceToDomainValue::type_id() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.type_id)
  return _internal_type_id();
}
inline void CoerceToDomainValue::set_type_id(::uint32_t value) {
  _internal_set_type_id(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomainValue.type_id)
}
inline ::uint32_t CoerceToDomainValue::_internal_type_id() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_id_;
}
inline void CoerceToDomainValue::_internal_set_type_id(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_id_ = value;
}

// int32 type_mod = 3 [json_name = "typeMod"];
inline void CoerceToDomainValue::clear_type_mod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_mod_ = 0;
}
inline ::int32_t CoerceToDomainValue::type_mod() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.type_mod)
  return _internal_type_mod();
}
inline void CoerceToDomainValue::set_type_mod(::int32_t value) {
  _internal_set_type_mod(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomainValue.type_mod)
}
inline ::int32_t CoerceToDomainValue::_internal_type_mod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_mod_;
}
inline void CoerceToDomainValue::_internal_set_type_mod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_mod_ = value;
}

// uint32 collation = 4 [json_name = "collation"];
inline void CoerceToDomainValue::clear_collation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.collation_ = 0u;
}
inline ::uint32_t CoerceToDomainValue::collation() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.collation)
  return _internal_collation();
}
inline void CoerceToDomainValue::set_collation(::uint32_t value) {
  _internal_set_collation(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomainValue.collation)
}
inline ::uint32_t CoerceToDomainValue::_internal_collation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.collation_;
}
inline void CoerceToDomainValue::_internal_set_collation(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.collation_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void CoerceToDomainValue::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t CoerceToDomainValue::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.location)
  return _internal_location();
}
inline void CoerceToDomainValue::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CoerceToDomainValue.location)
}
inline ::int32_t CoerceToDomainValue::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void CoerceToDomainValue::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// SetToDefault

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool SetToDefault::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void SetToDefault::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& SetToDefault::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SetToDefault::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SetToDefault.xpr)
  return _internal_xpr();
}
inline void SetToDefault::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SetToDefault.xpr)
}
inline ::pg_query::Node* SetToDefault::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SetToDefault::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SetToDefault.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SetToDefault::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* SetToDefault::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.SetToDefault.xpr)
  return _msg;
}
inline void SetToDefault::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SetToDefault.xpr)
}

// uint32 type_id = 2 [json_name = "typeId"];
inline void SetToDefault::clear_type_id() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_id_ = 0u;
}
inline ::uint32_t SetToDefault::type_id() const {
  // @@protoc_insertion_point(field_get:pg_query.SetToDefault.type_id)
  return _internal_type_id();
}
inline void SetToDefault::set_type_id(::uint32_t value) {
  _internal_set_type_id(value);
  // @@protoc_insertion_point(field_set:pg_query.SetToDefault.type_id)
}
inline ::uint32_t SetToDefault::_internal_type_id() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_id_;
}
inline void SetToDefault::_internal_set_type_id(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_id_ = value;
}

// int32 type_mod = 3 [json_name = "typeMod"];
inline void SetToDefault::clear_type_mod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_mod_ = 0;
}
inline ::int32_t SetToDefault::type_mod() const {
  // @@protoc_insertion_point(field_get:pg_query.SetToDefault.type_mod)
  return _internal_type_mod();
}
inline void SetToDefault::set_type_mod(::int32_t value) {
  _internal_set_type_mod(value);
  // @@protoc_insertion_point(field_set:pg_query.SetToDefault.type_mod)
}
inline ::int32_t SetToDefault::_internal_type_mod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_mod_;
}
inline void SetToDefault::_internal_set_type_mod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_mod_ = value;
}

// uint32 collation = 4 [json_name = "collation"];
inline void SetToDefault::clear_collation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.collation_ = 0u;
}
inline ::uint32_t SetToDefault::collation() const {
  // @@protoc_insertion_point(field_get:pg_query.SetToDefault.collation)
  return _internal_collation();
}
inline void SetToDefault::set_collation(::uint32_t value) {
  _internal_set_collation(value);
  // @@protoc_insertion_point(field_set:pg_query.SetToDefault.collation)
}
inline ::uint32_t SetToDefault::_internal_collation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.collation_;
}
inline void SetToDefault::_internal_set_collation(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.collation_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void SetToDefault::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t SetToDefault::location() const {
  // @@protoc_insertion_point(field_get:pg_query.SetToDefault.location)
  return _internal_location();
}
inline void SetToDefault::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.SetToDefault.location)
}
inline ::int32_t SetToDefault::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void SetToDefault::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CurrentOfExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool CurrentOfExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void CurrentOfExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CurrentOfExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CurrentOfExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CurrentOfExpr.xpr)
  return _internal_xpr();
}
inline void CurrentOfExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CurrentOfExpr.xpr)
}
inline ::pg_query::Node* CurrentOfExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CurrentOfExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CurrentOfExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CurrentOfExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* CurrentOfExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.CurrentOfExpr.xpr)
  return _msg;
}
inline void CurrentOfExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CurrentOfExpr.xpr)
}

// uint32 cvarno = 2 [json_name = "cvarno"];
inline void CurrentOfExpr::clear_cvarno() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cvarno_ = 0u;
}
inline ::uint32_t CurrentOfExpr::cvarno() const {
  // @@protoc_insertion_point(field_get:pg_query.CurrentOfExpr.cvarno)
  return _internal_cvarno();
}
inline void CurrentOfExpr::set_cvarno(::uint32_t value) {
  _internal_set_cvarno(value);
  // @@protoc_insertion_point(field_set:pg_query.CurrentOfExpr.cvarno)
}
inline ::uint32_t CurrentOfExpr::_internal_cvarno() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cvarno_;
}
inline void CurrentOfExpr::_internal_set_cvarno(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cvarno_ = value;
}

// string cursor_name = 3 [json_name = "cursor_name"];
inline void CurrentOfExpr::clear_cursor_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cursor_name_.ClearToEmpty();
}
inline const std::string& CurrentOfExpr::cursor_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CurrentOfExpr.cursor_name)
  return _internal_cursor_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CurrentOfExpr::set_cursor_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cursor_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CurrentOfExpr.cursor_name)
}
inline std::string* CurrentOfExpr::mutable_cursor_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_cursor_name();
  // @@protoc_insertion_point(field_mutable:pg_query.CurrentOfExpr.cursor_name)
  return _s;
}
inline const std::string& CurrentOfExpr::_internal_cursor_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cursor_name_.Get();
}
inline void CurrentOfExpr::_internal_set_cursor_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cursor_name_.Set(value, GetArena());
}
inline std::string* CurrentOfExpr::_internal_mutable_cursor_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.cursor_name_.Mutable( GetArena());
}
inline std::string* CurrentOfExpr::release_cursor_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CurrentOfExpr.cursor_name)
  return _impl_.cursor_name_.Release();
}
inline void CurrentOfExpr::set_allocated_cursor_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cursor_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.cursor_name_.IsDefault()) {
          _impl_.cursor_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cursor_param_ = 0;
}
inline ::int32_t CurrentOfExpr::cursor_param() const {
  // @@protoc_insertion_point(field_get:pg_query.CurrentOfExpr.cursor_param)
  return _internal_cursor_param();
}
inline void CurrentOfExpr::set_cursor_param(::int32_t value) {
  _internal_set_cursor_param(value);
  // @@protoc_insertion_point(field_set:pg_query.CurrentOfExpr.cursor_param)
}
inline ::int32_t CurrentOfExpr::_internal_cursor_param() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cursor_param_;
}
inline void CurrentOfExpr::_internal_set_cursor_param(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cursor_param_ = value;
}

// -------------------------------------------------------------------

// NextValueExpr

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool NextValueExpr::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void NextValueExpr::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& NextValueExpr::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& NextValueExpr::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.NextValueExpr.xpr)
  return _internal_xpr();
}
inline void NextValueExpr::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NextValueExpr.xpr)
}
inline ::pg_query::Node* NextValueExpr::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* NextValueExpr::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.NextValueExpr.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* NextValueExpr::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* NextValueExpr::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.NextValueExpr.xpr)
  return _msg;
}
inline void NextValueExpr::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.NextValueExpr.xpr)
}

// uint32 seqid = 2 [json_name = "seqid"];
inline void NextValueExpr::clear_seqid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.seqid_ = 0u;
}
inline ::uint32_t NextValueExpr::seqid() const {
  // @@protoc_insertion_point(field_get:pg_query.NextValueExpr.seqid)
  return _internal_seqid();
}
inline void NextValueExpr::set_seqid(::uint32_t value) {
  _internal_set_seqid(value);
  // @@protoc_insertion_point(field_set:pg_query.NextValueExpr.seqid)
}
inline ::uint32_t NextValueExpr::_internal_seqid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.seqid_;
}
inline void NextValueExpr::_internal_set_seqid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.seqid_ = value;
}

// uint32 type_id = 3 [json_name = "typeId"];
inline void NextValueExpr::clear_type_id() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_id_ = 0u;
}
inline ::uint32_t NextValueExpr::type_id() const {
  // @@protoc_insertion_point(field_get:pg_query.NextValueExpr.type_id)
  return _internal_type_id();
}
inline void NextValueExpr::set_type_id(::uint32_t value) {
  _internal_set_type_id(value);
  // @@protoc_insertion_point(field_set:pg_query.NextValueExpr.type_id)
}
inline ::uint32_t NextValueExpr::_internal_type_id() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_id_;
}
inline void NextValueExpr::_internal_set_type_id(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_id_ = value;
}

// -------------------------------------------------------------------

// InferenceElem

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool InferenceElem::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void InferenceElem::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& InferenceElem::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& InferenceElem::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.InferenceElem.xpr)
  return _internal_xpr();
}
inline void InferenceElem::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InferenceElem.xpr)
}
inline ::pg_query::Node* InferenceElem::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* InferenceElem::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.InferenceElem.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* InferenceElem::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* InferenceElem::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.InferenceElem.xpr)
  return _msg;
}
inline void InferenceElem::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.InferenceElem.xpr)
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool InferenceElem::has_expr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.expr_ != nullptr);
  return value;
}
inline void InferenceElem::clear_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.expr_ != nullptr) _impl_.expr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& InferenceElem::_internal_expr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& InferenceElem::expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.InferenceElem.expr)
  return _internal_expr();
}
inline void InferenceElem::unsafe_arena_set_allocated_expr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.expr_);
  }
  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InferenceElem.expr)
}
inline ::pg_query::Node* InferenceElem::release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.expr_;
  _impl_.expr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* InferenceElem::unsafe_arena_release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.InferenceElem.expr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.expr_;
  _impl_.expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* InferenceElem::_internal_mutable_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.expr_;
}
inline ::pg_query::Node* InferenceElem::mutable_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.InferenceElem.expr)
  return _msg;
}
inline void InferenceElem::set_allocated_expr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.expr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.InferenceElem.expr)
}

// uint32 infercollid = 3 [json_name = "infercollid"];
inline void InferenceElem::clear_infercollid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.infercollid_ = 0u;
}
inline ::uint32_t InferenceElem::infercollid() const {
  // @@protoc_insertion_point(field_get:pg_query.InferenceElem.infercollid)
  return _internal_infercollid();
}
inline void InferenceElem::set_infercollid(::uint32_t value) {
  _internal_set_infercollid(value);
  // @@protoc_insertion_point(field_set:pg_query.InferenceElem.infercollid)
}
inline ::uint32_t InferenceElem::_internal_infercollid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.infercollid_;
}
inline void InferenceElem::_internal_set_infercollid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.infercollid_ = value;
}

// uint32 inferopclass = 4 [json_name = "inferopclass"];
inline void InferenceElem::clear_inferopclass() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inferopclass_ = 0u;
}
inline ::uint32_t InferenceElem::inferopclass() const {
  // @@protoc_insertion_point(field_get:pg_query.InferenceElem.inferopclass)
  return _internal_inferopclass();
}
inline void InferenceElem::set_inferopclass(::uint32_t value) {
  _internal_set_inferopclass(value);
  // @@protoc_insertion_point(field_set:pg_query.InferenceElem.inferopclass)
}
inline ::uint32_t InferenceElem::_internal_inferopclass() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inferopclass_;
}
inline void InferenceElem::_internal_set_inferopclass(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inferopclass_ = value;
}

// -------------------------------------------------------------------

// TargetEntry

// .pg_query.Node xpr = 1 [json_name = "xpr"];
inline bool TargetEntry::has_xpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.xpr_ != nullptr);
  return value;
}
inline void TargetEntry::clear_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.xpr_ != nullptr) _impl_.xpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& TargetEntry::_internal_xpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.xpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& TargetEntry::xpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.xpr)
  return _internal_xpr();
}
inline void TargetEntry::unsafe_arena_set_allocated_xpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpr_);
  }
  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TargetEntry.xpr)
}
inline ::pg_query::Node* TargetEntry::release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* TargetEntry::unsafe_arena_release_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.TargetEntry.xpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.xpr_;
  _impl_.xpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* TargetEntry::_internal_mutable_xpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.xpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.xpr_;
}
inline ::pg_query::Node* TargetEntry::mutable_xpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_xpr();
  // @@protoc_insertion_point(field_mutable:pg_query.TargetEntry.xpr)
  return _msg;
}
inline void TargetEntry::set_allocated_xpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.xpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.xpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.TargetEntry.xpr)
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool TargetEntry::has_expr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.expr_ != nullptr);
  return value;
}
inline void TargetEntry::clear_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.expr_ != nullptr) _impl_.expr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& TargetEntry::_internal_expr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& TargetEntry::expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.expr)
  return _internal_expr();
}
inline void TargetEntry::unsafe_arena_set_allocated_expr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.expr_);
  }
  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TargetEntry.expr)
}
inline ::pg_query::Node* TargetEntry::release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.expr_;
  _impl_.expr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* TargetEntry::unsafe_arena_release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.TargetEntry.expr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.expr_;
  _impl_.expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* TargetEntry::_internal_mutable_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.expr_;
}
inline ::pg_query::Node* TargetEntry::mutable_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.TargetEntry.expr)
  return _msg;
}
inline void TargetEntry::set_allocated_expr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.expr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.TargetEntry.expr)
}

// int32 resno = 3 [json_name = "resno"];
inline void TargetEntry::clear_resno() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resno_ = 0;
}
inline ::int32_t TargetEntry::resno() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resno)
  return _internal_resno();
}
inline void TargetEntry::set_resno(::int32_t value) {
  _internal_set_resno(value);
  // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resno)
}
inline ::int32_t TargetEntry::_internal_resno() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resno_;
}
inline void TargetEntry::_internal_set_resno(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resno_ = value;
}

// string resname = 4 [json_name = "resname"];
inline void TargetEntry::clear_resname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resname_.ClearToEmpty();
}
inline const std::string& TargetEntry::resname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resname)
  return _internal_resname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void TargetEntry::set_resname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resname)
}
inline std::string* TargetEntry::mutable_resname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_resname();
  // @@protoc_insertion_point(field_mutable:pg_query.TargetEntry.resname)
  return _s;
}
inline const std::string& TargetEntry::_internal_resname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resname_.Get();
}
inline void TargetEntry::_internal_set_resname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resname_.Set(value, GetArena());
}
inline std::string* TargetEntry::_internal_mutable_resname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.resname_.Mutable( GetArena());
}
inline std::string* TargetEntry::release_resname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.TargetEntry.resname)
  return _impl_.resname_.Release();
}
inline void TargetEntry::set_allocated_resname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.resname_.IsDefault()) {
          _impl_.resname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.TargetEntry.resname)
}

// uint32 ressortgroupref = 5 [json_name = "ressortgroupref"];
inline void TargetEntry::clear_ressortgroupref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ressortgroupref_ = 0u;
}
inline ::uint32_t TargetEntry::ressortgroupref() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.ressortgroupref)
  return _internal_ressortgroupref();
}
inline void TargetEntry::set_ressortgroupref(::uint32_t value) {
  _internal_set_ressortgroupref(value);
  // @@protoc_insertion_point(field_set:pg_query.TargetEntry.ressortgroupref)
}
inline ::uint32_t TargetEntry::_internal_ressortgroupref() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ressortgroupref_;
}
inline void TargetEntry::_internal_set_ressortgroupref(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ressortgroupref_ = value;
}

// uint32 resorigtbl = 6 [json_name = "resorigtbl"];
inline void TargetEntry::clear_resorigtbl() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resorigtbl_ = 0u;
}
inline ::uint32_t TargetEntry::resorigtbl() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resorigtbl)
  return _internal_resorigtbl();
}
inline void TargetEntry::set_resorigtbl(::uint32_t value) {
  _internal_set_resorigtbl(value);
  // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resorigtbl)
}
inline ::uint32_t TargetEntry::_internal_resorigtbl() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resorigtbl_;
}
inline void TargetEntry::_internal_set_resorigtbl(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resorigtbl_ = value;
}

// int32 resorigcol = 7 [json_name = "resorigcol"];
inline void TargetEntry::clear_resorigcol() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resorigcol_ = 0;
}
inline ::int32_t TargetEntry::resorigcol() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resorigcol)
  return _internal_resorigcol();
}
inline void TargetEntry::set_resorigcol(::int32_t value) {
  _internal_set_resorigcol(value);
  // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resorigcol)
}
inline ::int32_t TargetEntry::_internal_resorigcol() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resorigcol_;
}
inline void TargetEntry::_internal_set_resorigcol(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resorigcol_ = value;
}

// bool resjunk = 8 [json_name = "resjunk"];
inline void TargetEntry::clear_resjunk() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resjunk_ = false;
}
inline bool TargetEntry::resjunk() const {
  // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resjunk)
  return _internal_resjunk();
}
inline void TargetEntry::set_resjunk(bool value) {
  _internal_set_resjunk(value);
  // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resjunk)
}
inline bool TargetEntry::_internal_resjunk() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resjunk_;
}
inline void TargetEntry::_internal_set_resjunk(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.resjunk_ = value;
}

// -------------------------------------------------------------------

// RangeTblRef

// int32 rtindex = 1 [json_name = "rtindex"];
inline void RangeTblRef::clear_rtindex() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rtindex_ = 0;
}
inline ::int32_t RangeTblRef::rtindex() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblRef.rtindex)
  return _internal_rtindex();
}
inline void RangeTblRef::set_rtindex(::int32_t value) {
  _internal_set_rtindex(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblRef.rtindex)
}
inline ::int32_t RangeTblRef::_internal_rtindex() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.rtindex_;
}
inline void RangeTblRef::_internal_set_rtindex(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.rtindex_ = value;
}

// -------------------------------------------------------------------

// JoinExpr

// .pg_query.JoinType jointype = 1 [json_name = "jointype"];
inline void JoinExpr::clear_jointype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.jointype_ = 0;
}
inline ::pg_query::JoinType JoinExpr::jointype() const {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.jointype)
  return _internal_jointype();
}
inline void JoinExpr::set_jointype(::pg_query::JoinType value) {
  _internal_set_jointype(value);
  // @@protoc_insertion_point(field_set:pg_query.JoinExpr.jointype)
}
inline ::pg_query::JoinType JoinExpr::_internal_jointype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::JoinType>(_impl_.jointype_);
}
inline void JoinExpr::_internal_set_jointype(::pg_query::JoinType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.jointype_ = value;
}

// bool is_natural = 2 [json_name = "isNatural"];
inline void JoinExpr::clear_is_natural() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_natural_ = false;
}
inline bool JoinExpr::is_natural() const {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.is_natural)
  return _internal_is_natural();
}
inline void JoinExpr::set_is_natural(bool value) {
  _internal_set_is_natural(value);
  // @@protoc_insertion_point(field_set:pg_query.JoinExpr.is_natural)
}
inline bool JoinExpr::_internal_is_natural() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_natural_;
}
inline void JoinExpr::_internal_set_is_natural(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_natural_ = value;
}

// .pg_query.Node larg = 3 [json_name = "larg"];
inline bool JoinExpr::has_larg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.larg_ != nullptr);
  return value;
}
inline void JoinExpr::clear_larg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.larg_ != nullptr) _impl_.larg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& JoinExpr::_internal_larg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.larg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JoinExpr::larg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.larg)
  return _internal_larg();
}
inline void JoinExpr::unsafe_arena_set_allocated_larg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.larg_);
  }
  _impl_.larg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.larg)
}
inline ::pg_query::Node* JoinExpr::release_larg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.larg_;
  _impl_.larg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* JoinExpr::unsafe_arena_release_larg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JoinExpr.larg)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.larg_;
  _impl_.larg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JoinExpr::_internal_mutable_larg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.larg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.larg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.larg_;
}
inline ::pg_query::Node* JoinExpr::mutable_larg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_larg();
  // @@protoc_insertion_point(field_mutable:pg_query.JoinExpr.larg)
  return _msg;
}
inline void JoinExpr::set_allocated_larg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.larg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.larg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.larg)
}

// .pg_query.Node rarg = 4 [json_name = "rarg"];
inline bool JoinExpr::has_rarg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.rarg_ != nullptr);
  return value;
}
inline void JoinExpr::clear_rarg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.rarg_ != nullptr) _impl_.rarg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& JoinExpr::_internal_rarg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.rarg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JoinExpr::rarg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.rarg)
  return _internal_rarg();
}
inline void JoinExpr::unsafe_arena_set_allocated_rarg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.rarg_);
  }
  _impl_.rarg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.rarg)
}
inline ::pg_query::Node* JoinExpr::release_rarg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.rarg_;
  _impl_.rarg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* JoinExpr::unsafe_arena_release_rarg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JoinExpr.rarg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.rarg_;
  _impl_.rarg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JoinExpr::_internal_mutable_rarg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.rarg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.rarg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.rarg_;
}
inline ::pg_query::Node* JoinExpr::mutable_rarg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_rarg();
  // @@protoc_insertion_point(field_mutable:pg_query.JoinExpr.rarg)
  return _msg;
}
inline void JoinExpr::set_allocated_rarg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.rarg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.rarg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_using_clause().size();
}
inline int JoinExpr::using_clause_size() const {
  return _internal_using_clause_size();
}
inline void JoinExpr::clear_using_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.using_clause_.Clear();
}
inline ::pg_query::Node* JoinExpr::mutable_using_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.JoinExpr.using_clause)
  return _internal_mutable_using_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* JoinExpr::mutable_using_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.JoinExpr.using_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_using_clause();
}
inline const ::pg_query::Node& JoinExpr::using_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.using_clause)
  return _internal_using_clause().Get(index);
}
inline ::pg_query::Node* JoinExpr::add_using_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_using_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.JoinExpr.using_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& JoinExpr::using_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.JoinExpr.using_clause)
  return _internal_using_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
JoinExpr::_internal_using_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.using_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
JoinExpr::_internal_mutable_using_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.using_clause_;
}

// .pg_query.Alias join_using_alias = 6 [json_name = "join_using_alias"];
inline bool JoinExpr::has_join_using_alias() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.join_using_alias_ != nullptr);
  return value;
}
inline void JoinExpr::clear_join_using_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.join_using_alias_ != nullptr) _impl_.join_using_alias_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Alias& JoinExpr::_internal_join_using_alias() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Alias* p = _impl_.join_using_alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& JoinExpr::join_using_alias() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.join_using_alias)
  return _internal_join_using_alias();
}
inline void JoinExpr::unsafe_arena_set_allocated_join_using_alias(::pg_query::Alias* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.join_using_alias_);
  }
  _impl_.join_using_alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.join_using_alias)
}
inline ::pg_query::Alias* JoinExpr::release_join_using_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Alias* released = _impl_.join_using_alias_;
  _impl_.join_using_alias_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Alias* JoinExpr::unsafe_arena_release_join_using_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JoinExpr.join_using_alias)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Alias* temp = _impl_.join_using_alias_;
  _impl_.join_using_alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* JoinExpr::_internal_mutable_join_using_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.join_using_alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    _impl_.join_using_alias_ = reinterpret_cast<::pg_query::Alias*>(p);
  }
  return _impl_.join_using_alias_;
}
inline ::pg_query::Alias* JoinExpr::mutable_join_using_alias() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Alias* _msg = _internal_mutable_join_using_alias();
  // @@protoc_insertion_point(field_mutable:pg_query.JoinExpr.join_using_alias)
  return _msg;
}
inline void JoinExpr::set_allocated_join_using_alias(::pg_query::Alias* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Alias*>(_impl_.join_using_alias_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Alias*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.join_using_alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.join_using_alias)
}

// .pg_query.Node quals = 7 [json_name = "quals"];
inline bool JoinExpr::has_quals() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quals_ != nullptr);
  return value;
}
inline void JoinExpr::clear_quals() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.quals_ != nullptr) _impl_.quals_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::pg_query::Node& JoinExpr::_internal_quals() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.quals_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JoinExpr::quals() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.quals)
  return _internal_quals();
}
inline void JoinExpr::unsafe_arena_set_allocated_quals(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.quals_);
  }
  _impl_.quals_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.quals)
}
inline ::pg_query::Node* JoinExpr::release_quals() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::Node* released = _impl_.quals_;
  _impl_.quals_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* JoinExpr::unsafe_arena_release_quals() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JoinExpr.quals)

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::Node* temp = _impl_.quals_;
  _impl_.quals_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JoinExpr::_internal_mutable_quals() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.quals_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.quals_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.quals_;
}
inline ::pg_query::Node* JoinExpr::mutable_quals() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_quals();
  // @@protoc_insertion_point(field_mutable:pg_query.JoinExpr.quals)
  return _msg;
}
inline void JoinExpr::set_allocated_quals(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.quals_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }

  _impl_.quals_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.quals)
}

// .pg_query.Alias alias = 8 [json_name = "alias"];
inline bool JoinExpr::has_alias() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.alias_ != nullptr);
  return value;
}
inline void JoinExpr::clear_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.alias_ != nullptr) _impl_.alias_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::pg_query::Alias& JoinExpr::_internal_alias() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Alias* p = _impl_.alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& JoinExpr::alias() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.alias)
  return _internal_alias();
}
inline void JoinExpr::unsafe_arena_set_allocated_alias(::pg_query::Alias* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.alias_);
  }
  _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.alias)
}
inline ::pg_query::Alias* JoinExpr::release_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000010u;
  ::pg_query::Alias* released = _impl_.alias_;
  _impl_.alias_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Alias* JoinExpr::unsafe_arena_release_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JoinExpr.alias)

  _impl_._has_bits_[0] &= ~0x00000010u;
  ::pg_query::Alias* temp = _impl_.alias_;
  _impl_.alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* JoinExpr::_internal_mutable_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(p);
  }
  return _impl_.alias_;
}
inline ::pg_query::Alias* JoinExpr::mutable_alias() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Alias* _msg = _internal_mutable_alias();
  // @@protoc_insertion_point(field_mutable:pg_query.JoinExpr.alias)
  return _msg;
}
inline void JoinExpr::set_allocated_alias(::pg_query::Alias* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Alias*>(_impl_.alias_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Alias*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }

  _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.alias)
}

// int32 rtindex = 9 [json_name = "rtindex"];
inline void JoinExpr::clear_rtindex() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rtindex_ = 0;
}
inline ::int32_t JoinExpr::rtindex() const {
  // @@protoc_insertion_point(field_get:pg_query.JoinExpr.rtindex)
  return _internal_rtindex();
}
inline void JoinExpr::set_rtindex(::int32_t value) {
  _internal_set_rtindex(value);
  // @@protoc_insertion_point(field_set:pg_query.JoinExpr.rtindex)
}
inline ::int32_t JoinExpr::_internal_rtindex() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.rtindex_;
}
inline void JoinExpr::_internal_set_rtindex(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.rtindex_ = value;
}

// -------------------------------------------------------------------

// FromExpr

// repeated .pg_query.Node fromlist = 1 [json_name = "fromlist"];
inline int FromExpr::_internal_fromlist_size() const {
  return _internal_fromlist().size();
}
inline int FromExpr::fromlist_size() const {
  return _internal_fromlist_size();
}
inline void FromExpr::clear_fromlist() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fromlist_.Clear();
}
inline ::pg_query::Node* FromExpr::mutable_fromlist(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.FromExpr.fromlist)
  return _internal_mutable_fromlist()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* FromExpr::mutable_fromlist()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FromExpr.fromlist)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_fromlist();
}
inline const ::pg_query::Node& FromExpr::fromlist(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FromExpr.fromlist)
  return _internal_fromlist().Get(index);
}
inline ::pg_query::Node* FromExpr::add_fromlist() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_fromlist()->Add();
  // @@protoc_insertion_point(field_add:pg_query.FromExpr.fromlist)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& FromExpr::fromlist() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.FromExpr.fromlist)
  return _internal_fromlist();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
FromExpr::_internal_fromlist() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fromlist_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
FromExpr::_internal_mutable_fromlist() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.fromlist_;
}

// .pg_query.Node quals = 2 [json_name = "quals"];
inline bool FromExpr::has_quals() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quals_ != nullptr);
  return value;
}
inline void FromExpr::clear_quals() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.quals_ != nullptr) _impl_.quals_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& FromExpr::_internal_quals() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.quals_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FromExpr::quals() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FromExpr.quals)
  return _internal_quals();
}
inline void FromExpr::unsafe_arena_set_allocated_quals(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.quals_);
  }
  _impl_.quals_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FromExpr.quals)
}
inline ::pg_query::Node* FromExpr::release_quals() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.quals_;
  _impl_.quals_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* FromExpr::unsafe_arena_release_quals() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.FromExpr.quals)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.quals_;
  _impl_.quals_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FromExpr::_internal_mutable_quals() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.quals_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.quals_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.quals_;
}
inline ::pg_query::Node* FromExpr::mutable_quals() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_quals();
  // @@protoc_insertion_point(field_mutable:pg_query.FromExpr.quals)
  return _msg;
}
inline void FromExpr::set_allocated_quals(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.quals_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.quals_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.FromExpr.quals)
}

// -------------------------------------------------------------------

// OnConflictExpr

// .pg_query.OnConflictAction action = 1 [json_name = "action"];
inline void OnConflictExpr::clear_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.action_ = 0;
}
inline ::pg_query::OnConflictAction OnConflictExpr::action() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.action)
  return _internal_action();
}
inline void OnConflictExpr::set_action(::pg_query::OnConflictAction value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:pg_query.OnConflictExpr.action)
}
inline ::pg_query::OnConflictAction OnConflictExpr::_internal_action() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::OnConflictAction>(_impl_.action_);
}
inline void OnConflictExpr::_internal_set_action(::pg_query::OnConflictAction value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.action_ = value;
}

// repeated .pg_query.Node arbiter_elems = 2 [json_name = "arbiterElems"];
inline int OnConflictExpr::_internal_arbiter_elems_size() const {
  return _internal_arbiter_elems().size();
}
inline int OnConflictExpr::arbiter_elems_size() const {
  return _internal_arbiter_elems_size();
}
inline void OnConflictExpr::clear_arbiter_elems() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.arbiter_elems_.Clear();
}
inline ::pg_query::Node* OnConflictExpr::mutable_arbiter_elems(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.arbiter_elems)
  return _internal_mutable_arbiter_elems()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* OnConflictExpr::mutable_arbiter_elems()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.OnConflictExpr.arbiter_elems)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_arbiter_elems();
}
inline const ::pg_query::Node& OnConflictExpr::arbiter_elems(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.arbiter_elems)
  return _internal_arbiter_elems().Get(index);
}
inline ::pg_query::Node* OnConflictExpr::add_arbiter_elems() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_arbiter_elems()->Add();
  // @@protoc_insertion_point(field_add:pg_query.OnConflictExpr.arbiter_elems)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& OnConflictExpr::arbiter_elems() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.OnConflictExpr.arbiter_elems)
  return _internal_arbiter_elems();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
OnConflictExpr::_internal_arbiter_elems() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.arbiter_elems_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
OnConflictExpr::_internal_mutable_arbiter_elems() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.arbiter_elems_;
}

// .pg_query.Node arbiter_where = 3 [json_name = "arbiterWhere"];
inline bool OnConflictExpr::has_arbiter_where() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arbiter_where_ != nullptr);
  return value;
}
inline void OnConflictExpr::clear_arbiter_where() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arbiter_where_ != nullptr) _impl_.arbiter_where_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& OnConflictExpr::_internal_arbiter_where() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arbiter_where_);
  }
  _impl_.arbiter_where_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OnConflictExpr.arbiter_where)
}
inline ::pg_query::Node* OnConflictExpr::release_arbiter_where() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.arbiter_where_;
  _impl_.arbiter_where_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* OnConflictExpr::unsafe_arena_release_arbiter_where() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.OnConflictExpr.arbiter_where)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.arbiter_where_;
  _impl_.arbiter_where_ = nullptr;
  return temp;
}
inline ::pg_query::Node* OnConflictExpr::_internal_mutable_arbiter_where() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.arbiter_where_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arbiter_where_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arbiter_where_;
}
inline ::pg_query::Node* OnConflictExpr::mutable_arbiter_where() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arbiter_where();
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.arbiter_where)
  return _msg;
}
inline void OnConflictExpr::set_allocated_arbiter_where(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arbiter_where_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.arbiter_where_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.OnConflictExpr.arbiter_where)
}

// uint32 constraint = 4 [json_name = "constraint"];
inline void OnConflictExpr::clear_constraint() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.constraint_ = 0u;
}
inline ::uint32_t OnConflictExpr::constraint() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.constraint)
  return _internal_constraint();
}
inline void OnConflictExpr::set_constraint(::uint32_t value) {
  _internal_set_constraint(value);
  // @@protoc_insertion_point(field_set:pg_query.OnConflictExpr.constraint)
}
inline ::uint32_t OnConflictExpr::_internal_constraint() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.constraint_;
}
inline void OnConflictExpr::_internal_set_constraint(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.constraint_ = value;
}

// repeated .pg_query.Node on_conflict_set = 5 [json_name = "onConflictSet"];
inline int OnConflictExpr::_internal_on_conflict_set_size() const {
  return _internal_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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.on_conflict_set_.Clear();
}
inline ::pg_query::Node* OnConflictExpr::mutable_on_conflict_set(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.on_conflict_set)
  return _internal_mutable_on_conflict_set()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* OnConflictExpr::mutable_on_conflict_set()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.OnConflictExpr.on_conflict_set)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_on_conflict_set();
}
inline const ::pg_query::Node& OnConflictExpr::on_conflict_set(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.on_conflict_set)
  return _internal_on_conflict_set().Get(index);
}
inline ::pg_query::Node* OnConflictExpr::add_on_conflict_set() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_on_conflict_set()->Add();
  // @@protoc_insertion_point(field_add:pg_query.OnConflictExpr.on_conflict_set)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& OnConflictExpr::on_conflict_set() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.OnConflictExpr.on_conflict_set)
  return _internal_on_conflict_set();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
OnConflictExpr::_internal_on_conflict_set() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.on_conflict_set_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
OnConflictExpr::_internal_mutable_on_conflict_set() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.on_conflict_set_;
}

// .pg_query.Node on_conflict_where = 6 [json_name = "onConflictWhere"];
inline bool OnConflictExpr::has_on_conflict_where() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.on_conflict_where_ != nullptr);
  return value;
}
inline void OnConflictExpr::clear_on_conflict_where() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.on_conflict_where_ != nullptr) _impl_.on_conflict_where_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& OnConflictExpr::_internal_on_conflict_where() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.on_conflict_where_);
  }
  _impl_.on_conflict_where_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OnConflictExpr.on_conflict_where)
}
inline ::pg_query::Node* OnConflictExpr::release_on_conflict_where() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.on_conflict_where_;
  _impl_.on_conflict_where_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* OnConflictExpr::unsafe_arena_release_on_conflict_where() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.OnConflictExpr.on_conflict_where)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.on_conflict_where_;
  _impl_.on_conflict_where_ = nullptr;
  return temp;
}
inline ::pg_query::Node* OnConflictExpr::_internal_mutable_on_conflict_where() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.on_conflict_where_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.on_conflict_where_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.on_conflict_where_;
}
inline ::pg_query::Node* OnConflictExpr::mutable_on_conflict_where() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_on_conflict_where();
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.on_conflict_where)
  return _msg;
}
inline void OnConflictExpr::set_allocated_on_conflict_where(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.on_conflict_where_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.on_conflict_where_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.excl_rel_index_ = 0;
}
inline ::int32_t OnConflictExpr::excl_rel_index() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.excl_rel_index)
  return _internal_excl_rel_index();
}
inline void OnConflictExpr::set_excl_rel_index(::int32_t value) {
  _internal_set_excl_rel_index(value);
  // @@protoc_insertion_point(field_set:pg_query.OnConflictExpr.excl_rel_index)
}
inline ::int32_t OnConflictExpr::_internal_excl_rel_index() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.excl_rel_index_;
}
inline void OnConflictExpr::_internal_set_excl_rel_index(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.excl_rel_index_ = value;
}

// repeated .pg_query.Node excl_rel_tlist = 8 [json_name = "exclRelTlist"];
inline int OnConflictExpr::_internal_excl_rel_tlist_size() const {
  return _internal_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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.excl_rel_tlist_.Clear();
}
inline ::pg_query::Node* OnConflictExpr::mutable_excl_rel_tlist(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.excl_rel_tlist)
  return _internal_mutable_excl_rel_tlist()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* OnConflictExpr::mutable_excl_rel_tlist()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.OnConflictExpr.excl_rel_tlist)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_excl_rel_tlist();
}
inline const ::pg_query::Node& OnConflictExpr::excl_rel_tlist(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.excl_rel_tlist)
  return _internal_excl_rel_tlist().Get(index);
}
inline ::pg_query::Node* OnConflictExpr::add_excl_rel_tlist() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_excl_rel_tlist()->Add();
  // @@protoc_insertion_point(field_add:pg_query.OnConflictExpr.excl_rel_tlist)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& OnConflictExpr::excl_rel_tlist() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.OnConflictExpr.excl_rel_tlist)
  return _internal_excl_rel_tlist();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
OnConflictExpr::_internal_excl_rel_tlist() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.excl_rel_tlist_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
OnConflictExpr::_internal_mutable_excl_rel_tlist() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.excl_rel_tlist_;
}

// -------------------------------------------------------------------

// Query

// .pg_query.CmdType command_type = 1 [json_name = "commandType"];
inline void Query::clear_command_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.command_type_ = 0;
}
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::set_command_type(::pg_query::CmdType value) {
  _internal_set_command_type(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.command_type)
}
inline ::pg_query::CmdType Query::_internal_command_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CmdType>(_impl_.command_type_);
}
inline void Query::_internal_set_command_type(::pg_query::CmdType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.command_type_ = value;
}

// .pg_query.QuerySource query_source = 2 [json_name = "querySource"];
inline void Query::clear_query_source() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.query_source_ = 0;
}
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::set_query_source(::pg_query::QuerySource value) {
  _internal_set_query_source(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.query_source)
}
inline ::pg_query::QuerySource Query::_internal_query_source() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::QuerySource>(_impl_.query_source_);
}
inline void Query::_internal_set_query_source(::pg_query::QuerySource value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.query_source_ = value;
}

// bool can_set_tag = 3 [json_name = "canSetTag"];
inline void Query::clear_can_set_tag() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.can_set_tag_ = false;
}
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::set_can_set_tag(bool value) {
  _internal_set_can_set_tag(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.can_set_tag)
}
inline bool Query::_internal_can_set_tag() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.can_set_tag_;
}
inline void Query::_internal_set_can_set_tag(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.can_set_tag_ = value;
}

// .pg_query.Node utility_stmt = 4 [json_name = "utilityStmt"];
inline bool Query::has_utility_stmt() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.utility_stmt_ != nullptr);
  return value;
}
inline void Query::clear_utility_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.utility_stmt_ != nullptr) _impl_.utility_stmt_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& Query::_internal_utility_stmt() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.utility_stmt_);
  }
  _impl_.utility_stmt_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.utility_stmt)
}
inline ::pg_query::Node* Query::release_utility_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.utility_stmt_;
  _impl_.utility_stmt_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* Query::unsafe_arena_release_utility_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Query.utility_stmt)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.utility_stmt_;
  _impl_.utility_stmt_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Query::_internal_mutable_utility_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.utility_stmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.utility_stmt_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.utility_stmt_;
}
inline ::pg_query::Node* Query::mutable_utility_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_utility_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.Query.utility_stmt)
  return _msg;
}
inline void Query::set_allocated_utility_stmt(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.utility_stmt_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.utility_stmt_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.utility_stmt)
}

// int32 result_relation = 5 [json_name = "resultRelation"];
inline void Query::clear_result_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.result_relation_ = 0;
}
inline ::int32_t Query::result_relation() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.result_relation)
  return _internal_result_relation();
}
inline void Query::set_result_relation(::int32_t value) {
  _internal_set_result_relation(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.result_relation)
}
inline ::int32_t Query::_internal_result_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.result_relation_;
}
inline void Query::_internal_set_result_relation(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.result_relation_ = value;
}

// bool has_aggs = 6 [json_name = "hasAggs"];
inline void Query::clear_has_aggs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.has_aggs_ = false;
}
inline bool Query::has_aggs() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.has_aggs)
  return _internal_has_aggs();
}
inline void Query::set_has_aggs(bool value) {
  _internal_set_has_aggs(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_aggs)
}
inline bool Query::_internal_has_aggs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.has_aggs_;
}
inline void Query::_internal_set_has_aggs(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.has_aggs_ = value;
}

// bool has_window_funcs = 7 [json_name = "hasWindowFuncs"];
inline void Query::clear_has_window_funcs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.has_window_funcs_ = false;
}
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::set_has_window_funcs(bool value) {
  _internal_set_has_window_funcs(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_window_funcs)
}
inline bool Query::_internal_has_window_funcs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.has_window_funcs_;
}
inline void Query::_internal_set_has_window_funcs(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.has_window_funcs_ = value;
}

// bool has_target_srfs = 8 [json_name = "hasTargetSRFs"];
inline void Query::clear_has_target_srfs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.has_target_srfs_ = false;
}
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::set_has_target_srfs(bool value) {
  _internal_set_has_target_srfs(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_target_srfs)
}
inline bool Query::_internal_has_target_srfs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.has_target_srfs_;
}
inline void Query::_internal_set_has_target_srfs(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.has_target_srfs_ = value;
}

// bool has_sub_links = 9 [json_name = "hasSubLinks"];
inline void Query::clear_has_sub_links() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.has_sub_links_ = false;
}
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::set_has_sub_links(bool value) {
  _internal_set_has_sub_links(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_sub_links)
}
inline bool Query::_internal_has_sub_links() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.has_sub_links_;
}
inline void Query::_internal_set_has_sub_links(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.has_sub_links_ = value;
}

// bool has_distinct_on = 10 [json_name = "hasDistinctOn"];
inline void Query::clear_has_distinct_on() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.has_distinct_on_ = false;
}
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::set_has_distinct_on(bool value) {
  _internal_set_has_distinct_on(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_distinct_on)
}
inline bool Query::_internal_has_distinct_on() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.has_distinct_on_;
}
inline void Query::_internal_set_has_distinct_on(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.has_distinct_on_ = value;
}

// bool has_recursive = 11 [json_name = "hasRecursive"];
inline void Query::clear_has_recursive() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.has_recursive_ = false;
}
inline bool Query::has_recursive() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.has_recursive)
  return _internal_has_recursive();
}
inline void Query::set_has_recursive(bool value) {
  _internal_set_has_recursive(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_recursive)
}
inline bool Query::_internal_has_recursive() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.has_recursive_;
}
inline void Query::_internal_set_has_recursive(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.has_recursive_ = value;
}

// bool has_modifying_cte = 12 [json_name = "hasModifyingCTE"];
inline void Query::clear_has_modifying_cte() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.has_modifying_cte_ = false;
}
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::set_has_modifying_cte(bool value) {
  _internal_set_has_modifying_cte(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_modifying_cte)
}
inline bool Query::_internal_has_modifying_cte() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.has_modifying_cte_;
}
inline void Query::_internal_set_has_modifying_cte(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.has_modifying_cte_ = value;
}

// bool has_for_update = 13 [json_name = "hasForUpdate"];
inline void Query::clear_has_for_update() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.has_for_update_ = false;
}
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::set_has_for_update(bool value) {
  _internal_set_has_for_update(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_for_update)
}
inline bool Query::_internal_has_for_update() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.has_for_update_;
}
inline void Query::_internal_set_has_for_update(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.has_for_update_ = value;
}

// bool has_row_security = 14 [json_name = "hasRowSecurity"];
inline void Query::clear_has_row_security() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.has_row_security_ = false;
}
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::set_has_row_security(bool value) {
  _internal_set_has_row_security(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.has_row_security)
}
inline bool Query::_internal_has_row_security() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.has_row_security_;
}
inline void Query::_internal_set_has_row_security(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.has_row_security_ = value;
}

// bool is_return = 15 [json_name = "isReturn"];
inline void Query::clear_is_return() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_return_ = false;
}
inline bool Query::is_return() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.is_return)
  return _internal_is_return();
}
inline void Query::set_is_return(bool value) {
  _internal_set_is_return(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.is_return)
}
inline bool Query::_internal_is_return() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_return_;
}
inline void Query::_internal_set_is_return(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_return_ = value;
}

// repeated .pg_query.Node cte_list = 16 [json_name = "cteList"];
inline int Query::_internal_cte_list_size() const {
  return _internal_cte_list().size();
}
inline int Query::cte_list_size() const {
  return _internal_cte_list_size();
}
inline void Query::clear_cte_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cte_list_.Clear();
}
inline ::pg_query::Node* Query::mutable_cte_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.cte_list)
  return _internal_mutable_cte_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_cte_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.cte_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_cte_list();
}
inline const ::pg_query::Node& Query::cte_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.cte_list)
  return _internal_cte_list().Get(index);
}
inline ::pg_query::Node* Query::add_cte_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_cte_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.cte_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::cte_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.cte_list)
  return _internal_cte_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_cte_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cte_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_cte_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.cte_list_;
}

// repeated .pg_query.Node rtable = 17 [json_name = "rtable"];
inline int Query::_internal_rtable_size() const {
  return _internal_rtable().size();
}
inline int Query::rtable_size() const {
  return _internal_rtable_size();
}
inline void Query::clear_rtable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rtable_.Clear();
}
inline ::pg_query::Node* Query::mutable_rtable(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.rtable)
  return _internal_mutable_rtable()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_rtable()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.rtable)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_rtable();
}
inline const ::pg_query::Node& Query::rtable(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.rtable)
  return _internal_rtable().Get(index);
}
inline ::pg_query::Node* Query::add_rtable() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_rtable()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.rtable)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::rtable() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.rtable)
  return _internal_rtable();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_rtable() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.rtable_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_rtable() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.rtable_;
}

// repeated .pg_query.Node rteperminfos = 18 [json_name = "rteperminfos"];
inline int Query::_internal_rteperminfos_size() const {
  return _internal_rteperminfos().size();
}
inline int Query::rteperminfos_size() const {
  return _internal_rteperminfos_size();
}
inline void Query::clear_rteperminfos() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rteperminfos_.Clear();
}
inline ::pg_query::Node* Query::mutable_rteperminfos(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.rteperminfos)
  return _internal_mutable_rteperminfos()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_rteperminfos()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.rteperminfos)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_rteperminfos();
}
inline const ::pg_query::Node& Query::rteperminfos(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.rteperminfos)
  return _internal_rteperminfos().Get(index);
}
inline ::pg_query::Node* Query::add_rteperminfos() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_rteperminfos()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.rteperminfos)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::rteperminfos() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.rteperminfos)
  return _internal_rteperminfos();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_rteperminfos() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.rteperminfos_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_rteperminfos() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.rteperminfos_;
}

// .pg_query.FromExpr jointree = 19 [json_name = "jointree"];
inline bool Query::has_jointree() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.jointree_ != nullptr);
  return value;
}
inline void Query::clear_jointree() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.jointree_ != nullptr) _impl_.jointree_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::FromExpr& Query::_internal_jointree() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::FromExpr* p = _impl_.jointree_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::FromExpr&>(::pg_query::_FromExpr_default_instance_);
}
inline const ::pg_query::FromExpr& Query::jointree() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.jointree)
  return _internal_jointree();
}
inline void Query::unsafe_arena_set_allocated_jointree(::pg_query::FromExpr* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.jointree_);
  }
  _impl_.jointree_ = reinterpret_cast<::pg_query::FromExpr*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.jointree)
}
inline ::pg_query::FromExpr* Query::release_jointree() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::FromExpr* released = _impl_.jointree_;
  _impl_.jointree_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::FromExpr* Query::unsafe_arena_release_jointree() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Query.jointree)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::FromExpr* temp = _impl_.jointree_;
  _impl_.jointree_ = nullptr;
  return temp;
}
inline ::pg_query::FromExpr* Query::_internal_mutable_jointree() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.jointree_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::FromExpr>(GetArena());
    _impl_.jointree_ = reinterpret_cast<::pg_query::FromExpr*>(p);
  }
  return _impl_.jointree_;
}
inline ::pg_query::FromExpr* Query::mutable_jointree() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::FromExpr* _msg = _internal_mutable_jointree();
  // @@protoc_insertion_point(field_mutable:pg_query.Query.jointree)
  return _msg;
}
inline void Query::set_allocated_jointree(::pg_query::FromExpr* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::FromExpr*>(_impl_.jointree_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::FromExpr*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.jointree_ = reinterpret_cast<::pg_query::FromExpr*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.jointree)
}

// repeated .pg_query.Node merge_action_list = 20 [json_name = "mergeActionList"];
inline int Query::_internal_merge_action_list_size() const {
  return _internal_merge_action_list().size();
}
inline int Query::merge_action_list_size() const {
  return _internal_merge_action_list_size();
}
inline void Query::clear_merge_action_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.merge_action_list_.Clear();
}
inline ::pg_query::Node* Query::mutable_merge_action_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.merge_action_list)
  return _internal_mutable_merge_action_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_merge_action_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.merge_action_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_merge_action_list();
}
inline const ::pg_query::Node& Query::merge_action_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.merge_action_list)
  return _internal_merge_action_list().Get(index);
}
inline ::pg_query::Node* Query::add_merge_action_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_merge_action_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.merge_action_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::merge_action_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.merge_action_list)
  return _internal_merge_action_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_merge_action_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.merge_action_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_merge_action_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.merge_action_list_;
}

// bool merge_use_outer_join = 21 [json_name = "mergeUseOuterJoin"];
inline void Query::clear_merge_use_outer_join() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.merge_use_outer_join_ = false;
}
inline bool Query::merge_use_outer_join() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.merge_use_outer_join)
  return _internal_merge_use_outer_join();
}
inline void Query::set_merge_use_outer_join(bool value) {
  _internal_set_merge_use_outer_join(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.merge_use_outer_join)
}
inline bool Query::_internal_merge_use_outer_join() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.merge_use_outer_join_;
}
inline void Query::_internal_set_merge_use_outer_join(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.merge_use_outer_join_ = value;
}

// repeated .pg_query.Node target_list = 22 [json_name = "targetList"];
inline int Query::_internal_target_list_size() const {
  return _internal_target_list().size();
}
inline int Query::target_list_size() const {
  return _internal_target_list_size();
}
inline void Query::clear_target_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.target_list_.Clear();
}
inline ::pg_query::Node* Query::mutable_target_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.target_list)
  return _internal_mutable_target_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_target_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.target_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_target_list();
}
inline const ::pg_query::Node& Query::target_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.target_list)
  return _internal_target_list().Get(index);
}
inline ::pg_query::Node* Query::add_target_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_target_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.target_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::target_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.target_list)
  return _internal_target_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_target_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.target_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_target_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.target_list_;
}

// .pg_query.OverridingKind override = 23 [json_name = "override"];
inline void Query::clear_override() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.override_ = 0;
}
inline ::pg_query::OverridingKind Query::override() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.override)
  return _internal_override();
}
inline void Query::set_override(::pg_query::OverridingKind value) {
  _internal_set_override(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.override)
}
inline ::pg_query::OverridingKind Query::_internal_override() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::OverridingKind>(_impl_.override_);
}
inline void Query::_internal_set_override(::pg_query::OverridingKind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.override_ = value;
}

// .pg_query.OnConflictExpr on_conflict = 24 [json_name = "onConflict"];
inline bool Query::has_on_conflict() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.on_conflict_ != nullptr);
  return value;
}
inline void Query::clear_on_conflict() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.on_conflict_ != nullptr) _impl_.on_conflict_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::OnConflictExpr& Query::_internal_on_conflict() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::OnConflictExpr* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.on_conflict_);
  }
  _impl_.on_conflict_ = reinterpret_cast<::pg_query::OnConflictExpr*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.on_conflict)
}
inline ::pg_query::OnConflictExpr* Query::release_on_conflict() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::OnConflictExpr* released = _impl_.on_conflict_;
  _impl_.on_conflict_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::OnConflictExpr* Query::unsafe_arena_release_on_conflict() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Query.on_conflict)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::OnConflictExpr* temp = _impl_.on_conflict_;
  _impl_.on_conflict_ = nullptr;
  return temp;
}
inline ::pg_query::OnConflictExpr* Query::_internal_mutable_on_conflict() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.on_conflict_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::OnConflictExpr>(GetArena());
    _impl_.on_conflict_ = reinterpret_cast<::pg_query::OnConflictExpr*>(p);
  }
  return _impl_.on_conflict_;
}
inline ::pg_query::OnConflictExpr* Query::mutable_on_conflict() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::OnConflictExpr* _msg = _internal_mutable_on_conflict();
  // @@protoc_insertion_point(field_mutable:pg_query.Query.on_conflict)
  return _msg;
}
inline void Query::set_allocated_on_conflict(::pg_query::OnConflictExpr* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::OnConflictExpr*>(_impl_.on_conflict_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::OnConflictExpr*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.on_conflict_ = reinterpret_cast<::pg_query::OnConflictExpr*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.on_conflict)
}

// repeated .pg_query.Node returning_list = 25 [json_name = "returningList"];
inline int Query::_internal_returning_list_size() const {
  return _internal_returning_list().size();
}
inline int Query::returning_list_size() const {
  return _internal_returning_list_size();
}
inline void Query::clear_returning_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.returning_list_.Clear();
}
inline ::pg_query::Node* Query::mutable_returning_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.returning_list)
  return _internal_mutable_returning_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_returning_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.returning_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_returning_list();
}
inline const ::pg_query::Node& Query::returning_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.returning_list)
  return _internal_returning_list().Get(index);
}
inline ::pg_query::Node* Query::add_returning_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_returning_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.returning_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::returning_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.returning_list)
  return _internal_returning_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_returning_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.returning_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_returning_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.returning_list_;
}

// repeated .pg_query.Node group_clause = 26 [json_name = "groupClause"];
inline int Query::_internal_group_clause_size() const {
  return _internal_group_clause().size();
}
inline int Query::group_clause_size() const {
  return _internal_group_clause_size();
}
inline void Query::clear_group_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.group_clause_.Clear();
}
inline ::pg_query::Node* Query::mutable_group_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.group_clause)
  return _internal_mutable_group_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_group_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.group_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_group_clause();
}
inline const ::pg_query::Node& Query::group_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.group_clause)
  return _internal_group_clause().Get(index);
}
inline ::pg_query::Node* Query::add_group_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_group_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.group_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::group_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.group_clause)
  return _internal_group_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_group_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.group_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_group_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.group_clause_;
}

// bool group_distinct = 27 [json_name = "groupDistinct"];
inline void Query::clear_group_distinct() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.group_distinct_ = false;
}
inline bool Query::group_distinct() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.group_distinct)
  return _internal_group_distinct();
}
inline void Query::set_group_distinct(bool value) {
  _internal_set_group_distinct(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.group_distinct)
}
inline bool Query::_internal_group_distinct() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.group_distinct_;
}
inline void Query::_internal_set_group_distinct(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.group_distinct_ = value;
}

// repeated .pg_query.Node grouping_sets = 28 [json_name = "groupingSets"];
inline int Query::_internal_grouping_sets_size() const {
  return _internal_grouping_sets().size();
}
inline int Query::grouping_sets_size() const {
  return _internal_grouping_sets_size();
}
inline void Query::clear_grouping_sets() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.grouping_sets_.Clear();
}
inline ::pg_query::Node* Query::mutable_grouping_sets(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.grouping_sets)
  return _internal_mutable_grouping_sets()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_grouping_sets()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.grouping_sets)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_grouping_sets();
}
inline const ::pg_query::Node& Query::grouping_sets(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.grouping_sets)
  return _internal_grouping_sets().Get(index);
}
inline ::pg_query::Node* Query::add_grouping_sets() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_grouping_sets()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.grouping_sets)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::grouping_sets() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.grouping_sets)
  return _internal_grouping_sets();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_grouping_sets() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.grouping_sets_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_grouping_sets() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.grouping_sets_;
}

// .pg_query.Node having_qual = 29 [json_name = "havingQual"];
inline bool Query::has_having_qual() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.having_qual_ != nullptr);
  return value;
}
inline void Query::clear_having_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.having_qual_ != nullptr) _impl_.having_qual_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::pg_query::Node& Query::_internal_having_qual() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.having_qual_);
  }
  _impl_.having_qual_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.having_qual)
}
inline ::pg_query::Node* Query::release_having_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::Node* released = _impl_.having_qual_;
  _impl_.having_qual_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* Query::unsafe_arena_release_having_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Query.having_qual)

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::Node* temp = _impl_.having_qual_;
  _impl_.having_qual_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Query::_internal_mutable_having_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.having_qual_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.having_qual_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.having_qual_;
}
inline ::pg_query::Node* Query::mutable_having_qual() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_having_qual();
  // @@protoc_insertion_point(field_mutable:pg_query.Query.having_qual)
  return _msg;
}
inline void Query::set_allocated_having_qual(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.having_qual_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }

  _impl_.having_qual_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.having_qual)
}

// repeated .pg_query.Node window_clause = 30 [json_name = "windowClause"];
inline int Query::_internal_window_clause_size() const {
  return _internal_window_clause().size();
}
inline int Query::window_clause_size() const {
  return _internal_window_clause_size();
}
inline void Query::clear_window_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.window_clause_.Clear();
}
inline ::pg_query::Node* Query::mutable_window_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.window_clause)
  return _internal_mutable_window_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_window_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.window_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_window_clause();
}
inline const ::pg_query::Node& Query::window_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.window_clause)
  return _internal_window_clause().Get(index);
}
inline ::pg_query::Node* Query::add_window_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_window_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.window_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::window_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.window_clause)
  return _internal_window_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_window_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.window_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_window_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.window_clause_;
}

// repeated .pg_query.Node distinct_clause = 31 [json_name = "distinctClause"];
inline int Query::_internal_distinct_clause_size() const {
  return _internal_distinct_clause().size();
}
inline int Query::distinct_clause_size() const {
  return _internal_distinct_clause_size();
}
inline void Query::clear_distinct_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.distinct_clause_.Clear();
}
inline ::pg_query::Node* Query::mutable_distinct_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.distinct_clause)
  return _internal_mutable_distinct_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_distinct_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.distinct_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_distinct_clause();
}
inline const ::pg_query::Node& Query::distinct_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.distinct_clause)
  return _internal_distinct_clause().Get(index);
}
inline ::pg_query::Node* Query::add_distinct_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_distinct_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.distinct_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::distinct_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.distinct_clause)
  return _internal_distinct_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_distinct_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.distinct_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_distinct_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.distinct_clause_;
}

// repeated .pg_query.Node sort_clause = 32 [json_name = "sortClause"];
inline int Query::_internal_sort_clause_size() const {
  return _internal_sort_clause().size();
}
inline int Query::sort_clause_size() const {
  return _internal_sort_clause_size();
}
inline void Query::clear_sort_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.sort_clause_.Clear();
}
inline ::pg_query::Node* Query::mutable_sort_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.sort_clause)
  return _internal_mutable_sort_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_sort_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.sort_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_sort_clause();
}
inline const ::pg_query::Node& Query::sort_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.sort_clause)
  return _internal_sort_clause().Get(index);
}
inline ::pg_query::Node* Query::add_sort_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_sort_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.sort_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::sort_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.sort_clause)
  return _internal_sort_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_sort_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.sort_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_sort_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.sort_clause_;
}

// .pg_query.Node limit_offset = 33 [json_name = "limitOffset"];
inline bool Query::has_limit_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.limit_offset_ != nullptr);
  return value;
}
inline void Query::clear_limit_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.limit_offset_ != nullptr) _impl_.limit_offset_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::pg_query::Node& Query::_internal_limit_offset() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.limit_offset_);
  }
  _impl_.limit_offset_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.limit_offset)
}
inline ::pg_query::Node* Query::release_limit_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000010u;
  ::pg_query::Node* released = _impl_.limit_offset_;
  _impl_.limit_offset_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* Query::unsafe_arena_release_limit_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Query.limit_offset)

  _impl_._has_bits_[0] &= ~0x00000010u;
  ::pg_query::Node* temp = _impl_.limit_offset_;
  _impl_.limit_offset_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Query::_internal_mutable_limit_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.limit_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.limit_offset_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.limit_offset_;
}
inline ::pg_query::Node* Query::mutable_limit_offset() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_limit_offset();
  // @@protoc_insertion_point(field_mutable:pg_query.Query.limit_offset)
  return _msg;
}
inline void Query::set_allocated_limit_offset(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.limit_offset_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }

  _impl_.limit_offset_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.limit_offset)
}

// .pg_query.Node limit_count = 34 [json_name = "limitCount"];
inline bool Query::has_limit_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.limit_count_ != nullptr);
  return value;
}
inline void Query::clear_limit_count() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.limit_count_ != nullptr) _impl_.limit_count_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::pg_query::Node& Query::_internal_limit_count() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.limit_count_);
  }
  _impl_.limit_count_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.limit_count)
}
inline ::pg_query::Node* Query::release_limit_count() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000020u;
  ::pg_query::Node* released = _impl_.limit_count_;
  _impl_.limit_count_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* Query::unsafe_arena_release_limit_count() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Query.limit_count)

  _impl_._has_bits_[0] &= ~0x00000020u;
  ::pg_query::Node* temp = _impl_.limit_count_;
  _impl_.limit_count_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Query::_internal_mutable_limit_count() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.limit_count_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.limit_count_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.limit_count_;
}
inline ::pg_query::Node* Query::mutable_limit_count() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_limit_count();
  // @@protoc_insertion_point(field_mutable:pg_query.Query.limit_count)
  return _msg;
}
inline void Query::set_allocated_limit_count(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.limit_count_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }

  _impl_.limit_count_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.limit_count)
}

// .pg_query.LimitOption limit_option = 35 [json_name = "limitOption"];
inline void Query::clear_limit_option() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.limit_option_ = 0;
}
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::set_limit_option(::pg_query::LimitOption value) {
  _internal_set_limit_option(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.limit_option)
}
inline ::pg_query::LimitOption Query::_internal_limit_option() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::LimitOption>(_impl_.limit_option_);
}
inline void Query::_internal_set_limit_option(::pg_query::LimitOption value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.limit_option_ = value;
}

// repeated .pg_query.Node row_marks = 36 [json_name = "rowMarks"];
inline int Query::_internal_row_marks_size() const {
  return _internal_row_marks().size();
}
inline int Query::row_marks_size() const {
  return _internal_row_marks_size();
}
inline void Query::clear_row_marks() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.row_marks_.Clear();
}
inline ::pg_query::Node* Query::mutable_row_marks(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.row_marks)
  return _internal_mutable_row_marks()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_row_marks()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.row_marks)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_row_marks();
}
inline const ::pg_query::Node& Query::row_marks(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.row_marks)
  return _internal_row_marks().Get(index);
}
inline ::pg_query::Node* Query::add_row_marks() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_row_marks()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.row_marks)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::row_marks() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.row_marks)
  return _internal_row_marks();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_row_marks() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.row_marks_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_row_marks() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.row_marks_;
}

// .pg_query.Node set_operations = 37 [json_name = "setOperations"];
inline bool Query::has_set_operations() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_operations_ != nullptr);
  return value;
}
inline void Query::clear_set_operations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.set_operations_ != nullptr) _impl_.set_operations_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::pg_query::Node& Query::_internal_set_operations() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.set_operations_);
  }
  _impl_.set_operations_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.set_operations)
}
inline ::pg_query::Node* Query::release_set_operations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000040u;
  ::pg_query::Node* released = _impl_.set_operations_;
  _impl_.set_operations_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* Query::unsafe_arena_release_set_operations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Query.set_operations)

  _impl_._has_bits_[0] &= ~0x00000040u;
  ::pg_query::Node* temp = _impl_.set_operations_;
  _impl_.set_operations_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Query::_internal_mutable_set_operations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.set_operations_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.set_operations_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.set_operations_;
}
inline ::pg_query::Node* Query::mutable_set_operations() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_set_operations();
  // @@protoc_insertion_point(field_mutable:pg_query.Query.set_operations)
  return _msg;
}
inline void Query::set_allocated_set_operations(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.set_operations_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }

  _impl_.set_operations_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Query.set_operations)
}

// repeated .pg_query.Node constraint_deps = 38 [json_name = "constraintDeps"];
inline int Query::_internal_constraint_deps_size() const {
  return _internal_constraint_deps().size();
}
inline int Query::constraint_deps_size() const {
  return _internal_constraint_deps_size();
}
inline void Query::clear_constraint_deps() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.constraint_deps_.Clear();
}
inline ::pg_query::Node* Query::mutable_constraint_deps(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.constraint_deps)
  return _internal_mutable_constraint_deps()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_constraint_deps()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.constraint_deps)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_constraint_deps();
}
inline const ::pg_query::Node& Query::constraint_deps(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.constraint_deps)
  return _internal_constraint_deps().Get(index);
}
inline ::pg_query::Node* Query::add_constraint_deps() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_constraint_deps()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.constraint_deps)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::constraint_deps() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.constraint_deps)
  return _internal_constraint_deps();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_constraint_deps() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.constraint_deps_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_constraint_deps() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.constraint_deps_;
}

// repeated .pg_query.Node with_check_options = 39 [json_name = "withCheckOptions"];
inline int Query::_internal_with_check_options_size() const {
  return _internal_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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.with_check_options_.Clear();
}
inline ::pg_query::Node* Query::mutable_with_check_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Query.with_check_options)
  return _internal_mutable_with_check_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Query::mutable_with_check_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Query.with_check_options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_with_check_options();
}
inline const ::pg_query::Node& Query::with_check_options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Query.with_check_options)
  return _internal_with_check_options().Get(index);
}
inline ::pg_query::Node* Query::add_with_check_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_with_check_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Query.with_check_options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Query::with_check_options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Query.with_check_options)
  return _internal_with_check_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Query::_internal_with_check_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.with_check_options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Query::_internal_mutable_with_check_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.with_check_options_;
}

// int32 stmt_location = 40 [json_name = "stmt_location"];
inline void Query::clear_stmt_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stmt_location_ = 0;
}
inline ::int32_t Query::stmt_location() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.stmt_location)
  return _internal_stmt_location();
}
inline void Query::set_stmt_location(::int32_t value) {
  _internal_set_stmt_location(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.stmt_location)
}
inline ::int32_t Query::_internal_stmt_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.stmt_location_;
}
inline void Query::_internal_set_stmt_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.stmt_location_ = value;
}

// int32 stmt_len = 41 [json_name = "stmt_len"];
inline void Query::clear_stmt_len() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stmt_len_ = 0;
}
inline ::int32_t Query::stmt_len() const {
  // @@protoc_insertion_point(field_get:pg_query.Query.stmt_len)
  return _internal_stmt_len();
}
inline void Query::set_stmt_len(::int32_t value) {
  _internal_set_stmt_len(value);
  // @@protoc_insertion_point(field_set:pg_query.Query.stmt_len)
}
inline ::int32_t Query::_internal_stmt_len() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.stmt_len_;
}
inline void Query::_internal_set_stmt_len(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.stmt_len_ = value;
}

// -------------------------------------------------------------------

// TypeName

// repeated .pg_query.Node names = 1 [json_name = "names"];
inline int TypeName::_internal_names_size() const {
  return _internal_names().size();
}
inline int TypeName::names_size() const {
  return _internal_names_size();
}
inline void TypeName::clear_names() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.names_.Clear();
}
inline ::pg_query::Node* TypeName::mutable_names(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TypeName.names)
  return _internal_mutable_names()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TypeName::mutable_names()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TypeName.names)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_names();
}
inline const ::pg_query::Node& TypeName::names(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.names)
  return _internal_names().Get(index);
}
inline ::pg_query::Node* TypeName::add_names() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_names()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TypeName.names)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TypeName::names() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TypeName.names)
  return _internal_names();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TypeName::_internal_names() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.names_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TypeName::_internal_mutable_names() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.names_;
}

// uint32 type_oid = 2 [json_name = "typeOid"];
inline void TypeName::clear_type_oid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_oid_ = 0u;
}
inline ::uint32_t TypeName::type_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.type_oid)
  return _internal_type_oid();
}
inline void TypeName::set_type_oid(::uint32_t value) {
  _internal_set_type_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.TypeName.type_oid)
}
inline ::uint32_t TypeName::_internal_type_oid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_oid_;
}
inline void TypeName::_internal_set_type_oid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_oid_ = value;
}

// bool setof = 3 [json_name = "setof"];
inline void TypeName::clear_setof() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.setof_ = false;
}
inline bool TypeName::setof() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.setof)
  return _internal_setof();
}
inline void TypeName::set_setof(bool value) {
  _internal_set_setof(value);
  // @@protoc_insertion_point(field_set:pg_query.TypeName.setof)
}
inline bool TypeName::_internal_setof() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.setof_;
}
inline void TypeName::_internal_set_setof(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.setof_ = value;
}

// bool pct_type = 4 [json_name = "pct_type"];
inline void TypeName::clear_pct_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.pct_type_ = false;
}
inline bool TypeName::pct_type() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.pct_type)
  return _internal_pct_type();
}
inline void TypeName::set_pct_type(bool value) {
  _internal_set_pct_type(value);
  // @@protoc_insertion_point(field_set:pg_query.TypeName.pct_type)
}
inline bool TypeName::_internal_pct_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.pct_type_;
}
inline void TypeName::_internal_set_pct_type(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.pct_type_ = value;
}

// repeated .pg_query.Node typmods = 5 [json_name = "typmods"];
inline int TypeName::_internal_typmods_size() const {
  return _internal_typmods().size();
}
inline int TypeName::typmods_size() const {
  return _internal_typmods_size();
}
inline void TypeName::clear_typmods() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.typmods_.Clear();
}
inline ::pg_query::Node* TypeName::mutable_typmods(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TypeName.typmods)
  return _internal_mutable_typmods()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TypeName::mutable_typmods()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TypeName.typmods)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_typmods();
}
inline const ::pg_query::Node& TypeName::typmods(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.typmods)
  return _internal_typmods().Get(index);
}
inline ::pg_query::Node* TypeName::add_typmods() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_typmods()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TypeName.typmods)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TypeName::typmods() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TypeName.typmods)
  return _internal_typmods();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TypeName::_internal_typmods() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.typmods_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TypeName::_internal_mutable_typmods() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.typmods_;
}

// int32 typemod = 6 [json_name = "typemod"];
inline void TypeName::clear_typemod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.typemod_ = 0;
}
inline ::int32_t TypeName::typemod() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.typemod)
  return _internal_typemod();
}
inline void TypeName::set_typemod(::int32_t value) {
  _internal_set_typemod(value);
  // @@protoc_insertion_point(field_set:pg_query.TypeName.typemod)
}
inline ::int32_t TypeName::_internal_typemod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.typemod_;
}
inline void TypeName::_internal_set_typemod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.typemod_ = value;
}

// repeated .pg_query.Node array_bounds = 7 [json_name = "arrayBounds"];
inline int TypeName::_internal_array_bounds_size() const {
  return _internal_array_bounds().size();
}
inline int TypeName::array_bounds_size() const {
  return _internal_array_bounds_size();
}
inline void TypeName::clear_array_bounds() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.array_bounds_.Clear();
}
inline ::pg_query::Node* TypeName::mutable_array_bounds(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TypeName.array_bounds)
  return _internal_mutable_array_bounds()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TypeName::mutable_array_bounds()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TypeName.array_bounds)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_array_bounds();
}
inline const ::pg_query::Node& TypeName::array_bounds(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.array_bounds)
  return _internal_array_bounds().Get(index);
}
inline ::pg_query::Node* TypeName::add_array_bounds() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_array_bounds()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TypeName.array_bounds)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TypeName::array_bounds() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TypeName.array_bounds)
  return _internal_array_bounds();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TypeName::_internal_array_bounds() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.array_bounds_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TypeName::_internal_mutable_array_bounds() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.array_bounds_;
}

// int32 location = 8 [json_name = "location"];
inline void TypeName::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t TypeName::location() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeName.location)
  return _internal_location();
}
inline void TypeName::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.TypeName.location)
}
inline ::int32_t TypeName::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void TypeName::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// ColumnRef

// repeated .pg_query.Node fields = 1 [json_name = "fields"];
inline int ColumnRef::_internal_fields_size() const {
  return _internal_fields().size();
}
inline int ColumnRef::fields_size() const {
  return _internal_fields_size();
}
inline void ColumnRef::clear_fields() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fields_.Clear();
}
inline ::pg_query::Node* ColumnRef::mutable_fields(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnRef.fields)
  return _internal_mutable_fields()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ColumnRef::mutable_fields()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ColumnRef.fields)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_fields();
}
inline const ::pg_query::Node& ColumnRef::fields(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ColumnRef.fields)
  return _internal_fields().Get(index);
}
inline ::pg_query::Node* ColumnRef::add_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_fields()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ColumnRef.fields)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ColumnRef::fields() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ColumnRef.fields)
  return _internal_fields();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ColumnRef::_internal_fields() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fields_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ColumnRef::_internal_mutable_fields() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.fields_;
}

// int32 location = 2 [json_name = "location"];
inline void ColumnRef::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t ColumnRef::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnRef.location)
  return _internal_location();
}
inline void ColumnRef::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnRef.location)
}
inline ::int32_t ColumnRef::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void ColumnRef::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// ParamRef

// int32 number = 1 [json_name = "number"];
inline void ParamRef::clear_number() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.number_ = 0;
}
inline ::int32_t ParamRef::number() const {
  // @@protoc_insertion_point(field_get:pg_query.ParamRef.number)
  return _internal_number();
}
inline void ParamRef::set_number(::int32_t value) {
  _internal_set_number(value);
  // @@protoc_insertion_point(field_set:pg_query.ParamRef.number)
}
inline ::int32_t ParamRef::_internal_number() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.number_;
}
inline void ParamRef::_internal_set_number(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.number_ = value;
}

// int32 location = 2 [json_name = "location"];
inline void ParamRef::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t ParamRef::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ParamRef.location)
  return _internal_location();
}
inline void ParamRef::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ParamRef.location)
}
inline ::int32_t ParamRef::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void ParamRef::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// A_Expr

// .pg_query.A_Expr_Kind kind = 1 [json_name = "kind"];
inline void A_Expr::clear_kind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.kind_ = 0;
}
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::set_kind(::pg_query::A_Expr_Kind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.A_Expr.kind)
}
inline ::pg_query::A_Expr_Kind A_Expr::_internal_kind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::A_Expr_Kind>(_impl_.kind_);
}
inline void A_Expr::_internal_set_kind(::pg_query::A_Expr_Kind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.kind_ = value;
}

// repeated .pg_query.Node name = 2 [json_name = "name"];
inline int A_Expr::_internal_name_size() const {
  return _internal_name().size();
}
inline int A_Expr::name_size() const {
  return _internal_name_size();
}
inline void A_Expr::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.Clear();
}
inline ::pg_query::Node* A_Expr::mutable_name(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.A_Expr.name)
  return _internal_mutable_name()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* A_Expr::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.A_Expr.name)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_name();
}
inline const ::pg_query::Node& A_Expr::name(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.A_Expr.name)
  return _internal_name().Get(index);
}
inline ::pg_query::Node* A_Expr::add_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_name()->Add();
  // @@protoc_insertion_point(field_add:pg_query.A_Expr.name)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& A_Expr::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.A_Expr.name)
  return _internal_name();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
A_Expr::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
A_Expr::_internal_mutable_name() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.name_;
}

// .pg_query.Node lexpr = 3 [json_name = "lexpr"];
inline bool A_Expr::has_lexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.lexpr_ != nullptr);
  return value;
}
inline void A_Expr::clear_lexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.lexpr_ != nullptr) _impl_.lexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& A_Expr::_internal_lexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.lexpr_);
  }
  _impl_.lexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Expr.lexpr)
}
inline ::pg_query::Node* A_Expr::release_lexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.lexpr_;
  _impl_.lexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* A_Expr::unsafe_arena_release_lexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.A_Expr.lexpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.lexpr_;
  _impl_.lexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* A_Expr::_internal_mutable_lexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.lexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.lexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.lexpr_;
}
inline ::pg_query::Node* A_Expr::mutable_lexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_lexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.A_Expr.lexpr)
  return _msg;
}
inline void A_Expr::set_allocated_lexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.lexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.lexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.A_Expr.lexpr)
}

// .pg_query.Node rexpr = 4 [json_name = "rexpr"];
inline bool A_Expr::has_rexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.rexpr_ != nullptr);
  return value;
}
inline void A_Expr::clear_rexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.rexpr_ != nullptr) _impl_.rexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& A_Expr::_internal_rexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.rexpr_);
  }
  _impl_.rexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Expr.rexpr)
}
inline ::pg_query::Node* A_Expr::release_rexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.rexpr_;
  _impl_.rexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* A_Expr::unsafe_arena_release_rexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.A_Expr.rexpr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.rexpr_;
  _impl_.rexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* A_Expr::_internal_mutable_rexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.rexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.rexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.rexpr_;
}
inline ::pg_query::Node* A_Expr::mutable_rexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_rexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.A_Expr.rexpr)
  return _msg;
}
inline void A_Expr::set_allocated_rexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.rexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.rexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.A_Expr.rexpr)
}

// int32 location = 5 [json_name = "location"];
inline void A_Expr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t A_Expr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.A_Expr.location)
  return _internal_location();
}
inline void A_Expr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.A_Expr.location)
}
inline ::int32_t A_Expr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void A_Expr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// TypeCast

// .pg_query.Node arg = 1 [json_name = "arg"];
inline bool TypeCast::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void TypeCast::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& TypeCast::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& TypeCast::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TypeCast.arg)
  return _internal_arg();
}
inline void TypeCast::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TypeCast.arg)
}
inline ::pg_query::Node* TypeCast::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* TypeCast::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.TypeCast.arg)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* TypeCast::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* TypeCast::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.TypeCast.arg)
  return _msg;
}
inline void TypeCast::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.TypeCast.arg)
}

// .pg_query.TypeName type_name = 2 [json_name = "typeName"];
inline bool TypeCast::has_type_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.type_name_ != nullptr);
  return value;
}
inline void TypeCast::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.type_name_ != nullptr) _impl_.type_name_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::TypeName& TypeCast::_internal_type_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_name_);
  }
  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TypeCast.type_name)
}
inline ::pg_query::TypeName* TypeCast::release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::TypeName* released = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* TypeCast::unsafe_arena_release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.TypeCast.type_name)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::TypeName* temp = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* TypeCast::_internal_mutable_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.type_name_;
}
inline ::pg_query::TypeName* TypeCast::mutable_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_type_name();
  // @@protoc_insertion_point(field_mutable:pg_query.TypeCast.type_name)
  return _msg;
}
inline void TypeCast::set_allocated_type_name(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.type_name_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.TypeCast.type_name)
}

// int32 location = 3 [json_name = "location"];
inline void TypeCast::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t TypeCast::location() const {
  // @@protoc_insertion_point(field_get:pg_query.TypeCast.location)
  return _internal_location();
}
inline void TypeCast::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.TypeCast.location)
}
inline ::int32_t TypeCast::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void TypeCast::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CollateClause

// .pg_query.Node arg = 1 [json_name = "arg"];
inline bool CollateClause::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void CollateClause::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CollateClause::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CollateClause::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CollateClause.arg)
  return _internal_arg();
}
inline void CollateClause::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CollateClause.arg)
}
inline ::pg_query::Node* CollateClause::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CollateClause::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CollateClause.arg)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CollateClause::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* CollateClause::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.CollateClause.arg)
  return _msg;
}
inline void CollateClause::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_collname().size();
}
inline int CollateClause::collname_size() const {
  return _internal_collname_size();
}
inline void CollateClause::clear_collname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.collname_.Clear();
}
inline ::pg_query::Node* CollateClause::mutable_collname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CollateClause.collname)
  return _internal_mutable_collname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CollateClause::mutable_collname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CollateClause.collname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_collname();
}
inline const ::pg_query::Node& CollateClause::collname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CollateClause.collname)
  return _internal_collname().Get(index);
}
inline ::pg_query::Node* CollateClause::add_collname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_collname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CollateClause.collname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CollateClause::collname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CollateClause.collname)
  return _internal_collname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CollateClause::_internal_collname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.collname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CollateClause::_internal_mutable_collname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.collname_;
}

// int32 location = 3 [json_name = "location"];
inline void CollateClause::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t CollateClause::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CollateClause.location)
  return _internal_location();
}
inline void CollateClause::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CollateClause.location)
}
inline ::int32_t CollateClause::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void CollateClause::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// RoleSpec

// .pg_query.RoleSpecType roletype = 1 [json_name = "roletype"];
inline void RoleSpec::clear_roletype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.roletype_ = 0;
}
inline ::pg_query::RoleSpecType RoleSpec::roletype() const {
  // @@protoc_insertion_point(field_get:pg_query.RoleSpec.roletype)
  return _internal_roletype();
}
inline void RoleSpec::set_roletype(::pg_query::RoleSpecType value) {
  _internal_set_roletype(value);
  // @@protoc_insertion_point(field_set:pg_query.RoleSpec.roletype)
}
inline ::pg_query::RoleSpecType RoleSpec::_internal_roletype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::RoleSpecType>(_impl_.roletype_);
}
inline void RoleSpec::_internal_set_roletype(::pg_query::RoleSpecType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.roletype_ = value;
}

// string rolename = 2 [json_name = "rolename"];
inline void RoleSpec::clear_rolename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rolename_.ClearToEmpty();
}
inline const std::string& RoleSpec::rolename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RoleSpec.rolename)
  return _internal_rolename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RoleSpec::set_rolename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.rolename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.RoleSpec.rolename)
}
inline std::string* RoleSpec::mutable_rolename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_rolename();
  // @@protoc_insertion_point(field_mutable:pg_query.RoleSpec.rolename)
  return _s;
}
inline const std::string& RoleSpec::_internal_rolename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.rolename_.Get();
}
inline void RoleSpec::_internal_set_rolename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.rolename_.Set(value, GetArena());
}
inline std::string* RoleSpec::_internal_mutable_rolename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.rolename_.Mutable( GetArena());
}
inline std::string* RoleSpec::release_rolename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RoleSpec.rolename)
  return _impl_.rolename_.Release();
}
inline void RoleSpec::set_allocated_rolename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rolename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.rolename_.IsDefault()) {
          _impl_.rolename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.RoleSpec.rolename)
}

// int32 location = 3 [json_name = "location"];
inline void RoleSpec::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t RoleSpec::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RoleSpec.location)
  return _internal_location();
}
inline void RoleSpec::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RoleSpec.location)
}
inline ::int32_t RoleSpec::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void RoleSpec::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// FuncCall

// repeated .pg_query.Node funcname = 1 [json_name = "funcname"];
inline int FuncCall::_internal_funcname_size() const {
  return _internal_funcname().size();
}
inline int FuncCall::funcname_size() const {
  return _internal_funcname_size();
}
inline void FuncCall::clear_funcname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funcname_.Clear();
}
inline ::pg_query::Node* FuncCall::mutable_funcname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.funcname)
  return _internal_mutable_funcname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* FuncCall::mutable_funcname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FuncCall.funcname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_funcname();
}
inline const ::pg_query::Node& FuncCall::funcname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.funcname)
  return _internal_funcname().Get(index);
}
inline ::pg_query::Node* FuncCall::add_funcname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_funcname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.FuncCall.funcname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& FuncCall::funcname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.FuncCall.funcname)
  return _internal_funcname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
FuncCall::_internal_funcname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funcname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
FuncCall::_internal_mutable_funcname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.funcname_;
}

// repeated .pg_query.Node args = 2 [json_name = "args"];
inline int FuncCall::_internal_args_size() const {
  return _internal_args().size();
}
inline int FuncCall::args_size() const {
  return _internal_args_size();
}
inline void FuncCall::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* FuncCall::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* FuncCall::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FuncCall.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& FuncCall::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* FuncCall::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.FuncCall.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& FuncCall::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.FuncCall.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
FuncCall::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
FuncCall::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// repeated .pg_query.Node agg_order = 3 [json_name = "agg_order"];
inline int FuncCall::_internal_agg_order_size() const {
  return _internal_agg_order().size();
}
inline int FuncCall::agg_order_size() const {
  return _internal_agg_order_size();
}
inline void FuncCall::clear_agg_order() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.agg_order_.Clear();
}
inline ::pg_query::Node* FuncCall::mutable_agg_order(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.agg_order)
  return _internal_mutable_agg_order()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* FuncCall::mutable_agg_order()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.FuncCall.agg_order)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_agg_order();
}
inline const ::pg_query::Node& FuncCall::agg_order(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_order)
  return _internal_agg_order().Get(index);
}
inline ::pg_query::Node* FuncCall::add_agg_order() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_agg_order()->Add();
  // @@protoc_insertion_point(field_add:pg_query.FuncCall.agg_order)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& FuncCall::agg_order() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.FuncCall.agg_order)
  return _internal_agg_order();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
FuncCall::_internal_agg_order() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.agg_order_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
FuncCall::_internal_mutable_agg_order() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.agg_order_;
}

// .pg_query.Node agg_filter = 4 [json_name = "agg_filter"];
inline bool FuncCall::has_agg_filter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.agg_filter_ != nullptr);
  return value;
}
inline void FuncCall::clear_agg_filter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.agg_filter_ != nullptr) _impl_.agg_filter_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& FuncCall::_internal_agg_filter() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.agg_filter_);
  }
  _impl_.agg_filter_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FuncCall.agg_filter)
}
inline ::pg_query::Node* FuncCall::release_agg_filter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.agg_filter_;
  _impl_.agg_filter_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* FuncCall::unsafe_arena_release_agg_filter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.FuncCall.agg_filter)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.agg_filter_;
  _impl_.agg_filter_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FuncCall::_internal_mutable_agg_filter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.agg_filter_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.agg_filter_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.agg_filter_;
}
inline ::pg_query::Node* FuncCall::mutable_agg_filter() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_agg_filter();
  // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.agg_filter)
  return _msg;
}
inline void FuncCall::set_allocated_agg_filter(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.agg_filter_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.agg_filter_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.FuncCall.agg_filter)
}

// .pg_query.WindowDef over = 5 [json_name = "over"];
inline bool FuncCall::has_over() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.over_ != nullptr);
  return value;
}
inline void FuncCall::clear_over() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.over_ != nullptr) _impl_.over_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::WindowDef& FuncCall::_internal_over() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::WindowDef* p = _impl_.over_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::WindowDef&>(::pg_query::_WindowDef_default_instance_);
}
inline const ::pg_query::WindowDef& FuncCall::over() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.over)
  return _internal_over();
}
inline void FuncCall::unsafe_arena_set_allocated_over(::pg_query::WindowDef* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.over_);
  }
  _impl_.over_ = reinterpret_cast<::pg_query::WindowDef*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FuncCall.over)
}
inline ::pg_query::WindowDef* FuncCall::release_over() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::WindowDef* released = _impl_.over_;
  _impl_.over_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::WindowDef* FuncCall::unsafe_arena_release_over() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.FuncCall.over)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::WindowDef* temp = _impl_.over_;
  _impl_.over_ = nullptr;
  return temp;
}
inline ::pg_query::WindowDef* FuncCall::_internal_mutable_over() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.over_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::WindowDef>(GetArena());
    _impl_.over_ = reinterpret_cast<::pg_query::WindowDef*>(p);
  }
  return _impl_.over_;
}
inline ::pg_query::WindowDef* FuncCall::mutable_over() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::WindowDef* _msg = _internal_mutable_over();
  // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.over)
  return _msg;
}
inline void FuncCall::set_allocated_over(::pg_query::WindowDef* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::WindowDef*>(_impl_.over_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::WindowDef*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.over_ = reinterpret_cast<::pg_query::WindowDef*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.FuncCall.over)
}

// bool agg_within_group = 6 [json_name = "agg_within_group"];
inline void FuncCall::clear_agg_within_group() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.agg_within_group_ = false;
}
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::set_agg_within_group(bool value) {
  _internal_set_agg_within_group(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncCall.agg_within_group)
}
inline bool FuncCall::_internal_agg_within_group() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.agg_within_group_;
}
inline void FuncCall::_internal_set_agg_within_group(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.agg_within_group_ = value;
}

// bool agg_star = 7 [json_name = "agg_star"];
inline void FuncCall::clear_agg_star() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.agg_star_ = false;
}
inline bool FuncCall::agg_star() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_star)
  return _internal_agg_star();
}
inline void FuncCall::set_agg_star(bool value) {
  _internal_set_agg_star(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncCall.agg_star)
}
inline bool FuncCall::_internal_agg_star() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.agg_star_;
}
inline void FuncCall::_internal_set_agg_star(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.agg_star_ = value;
}

// bool agg_distinct = 8 [json_name = "agg_distinct"];
inline void FuncCall::clear_agg_distinct() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.agg_distinct_ = false;
}
inline bool FuncCall::agg_distinct() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_distinct)
  return _internal_agg_distinct();
}
inline void FuncCall::set_agg_distinct(bool value) {
  _internal_set_agg_distinct(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncCall.agg_distinct)
}
inline bool FuncCall::_internal_agg_distinct() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.agg_distinct_;
}
inline void FuncCall::_internal_set_agg_distinct(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.agg_distinct_ = value;
}

// bool func_variadic = 9 [json_name = "func_variadic"];
inline void FuncCall::clear_func_variadic() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.func_variadic_ = false;
}
inline bool FuncCall::func_variadic() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.func_variadic)
  return _internal_func_variadic();
}
inline void FuncCall::set_func_variadic(bool value) {
  _internal_set_func_variadic(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncCall.func_variadic)
}
inline bool FuncCall::_internal_func_variadic() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.func_variadic_;
}
inline void FuncCall::_internal_set_func_variadic(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.func_variadic_ = value;
}

// .pg_query.CoercionForm funcformat = 10 [json_name = "funcformat"];
inline void FuncCall::clear_funcformat() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funcformat_ = 0;
}
inline ::pg_query::CoercionForm FuncCall::funcformat() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.funcformat)
  return _internal_funcformat();
}
inline void FuncCall::set_funcformat(::pg_query::CoercionForm value) {
  _internal_set_funcformat(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncCall.funcformat)
}
inline ::pg_query::CoercionForm FuncCall::_internal_funcformat() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CoercionForm>(_impl_.funcformat_);
}
inline void FuncCall::_internal_set_funcformat(::pg_query::CoercionForm value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.funcformat_ = value;
}

// int32 location = 11 [json_name = "location"];
inline void FuncCall::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t FuncCall::location() const {
  // @@protoc_insertion_point(field_get:pg_query.FuncCall.location)
  return _internal_location();
}
inline void FuncCall::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.FuncCall.location)
}
inline ::int32_t FuncCall::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void FuncCall::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// A_Star

// -------------------------------------------------------------------

// A_Indices

// bool is_slice = 1 [json_name = "is_slice"];
inline void A_Indices::clear_is_slice() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_slice_ = false;
}
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::set_is_slice(bool value) {
  _internal_set_is_slice(value);
  // @@protoc_insertion_point(field_set:pg_query.A_Indices.is_slice)
}
inline bool A_Indices::_internal_is_slice() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_slice_;
}
inline void A_Indices::_internal_set_is_slice(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_slice_ = value;
}

// .pg_query.Node lidx = 2 [json_name = "lidx"];
inline bool A_Indices::has_lidx() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.lidx_ != nullptr);
  return value;
}
inline void A_Indices::clear_lidx() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.lidx_ != nullptr) _impl_.lidx_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& A_Indices::_internal_lidx() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.lidx_);
  }
  _impl_.lidx_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Indices.lidx)
}
inline ::pg_query::Node* A_Indices::release_lidx() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.lidx_;
  _impl_.lidx_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* A_Indices::unsafe_arena_release_lidx() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.A_Indices.lidx)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.lidx_;
  _impl_.lidx_ = nullptr;
  return temp;
}
inline ::pg_query::Node* A_Indices::_internal_mutable_lidx() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.lidx_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.lidx_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.lidx_;
}
inline ::pg_query::Node* A_Indices::mutable_lidx() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_lidx();
  // @@protoc_insertion_point(field_mutable:pg_query.A_Indices.lidx)
  return _msg;
}
inline void A_Indices::set_allocated_lidx(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.lidx_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.lidx_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.A_Indices.lidx)
}

// .pg_query.Node uidx = 3 [json_name = "uidx"];
inline bool A_Indices::has_uidx() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.uidx_ != nullptr);
  return value;
}
inline void A_Indices::clear_uidx() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.uidx_ != nullptr) _impl_.uidx_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& A_Indices::_internal_uidx() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.uidx_);
  }
  _impl_.uidx_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Indices.uidx)
}
inline ::pg_query::Node* A_Indices::release_uidx() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.uidx_;
  _impl_.uidx_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* A_Indices::unsafe_arena_release_uidx() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.A_Indices.uidx)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.uidx_;
  _impl_.uidx_ = nullptr;
  return temp;
}
inline ::pg_query::Node* A_Indices::_internal_mutable_uidx() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.uidx_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.uidx_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.uidx_;
}
inline ::pg_query::Node* A_Indices::mutable_uidx() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_uidx();
  // @@protoc_insertion_point(field_mutable:pg_query.A_Indices.uidx)
  return _msg;
}
inline void A_Indices::set_allocated_uidx(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.uidx_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.uidx_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void A_Indirection::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& A_Indirection::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Indirection.arg)
}
inline ::pg_query::Node* A_Indirection::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* A_Indirection::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.A_Indirection.arg)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* A_Indirection::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* A_Indirection::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.A_Indirection.arg)
  return _msg;
}
inline void A_Indirection::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_indirection().size();
}
inline int A_Indirection::indirection_size() const {
  return _internal_indirection_size();
}
inline void A_Indirection::clear_indirection() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indirection_.Clear();
}
inline ::pg_query::Node* A_Indirection::mutable_indirection(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.A_Indirection.indirection)
  return _internal_mutable_indirection()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* A_Indirection::mutable_indirection()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.A_Indirection.indirection)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_indirection();
}
inline const ::pg_query::Node& A_Indirection::indirection(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.A_Indirection.indirection)
  return _internal_indirection().Get(index);
}
inline ::pg_query::Node* A_Indirection::add_indirection() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_indirection()->Add();
  // @@protoc_insertion_point(field_add:pg_query.A_Indirection.indirection)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& A_Indirection::indirection() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.A_Indirection.indirection)
  return _internal_indirection();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
A_Indirection::_internal_indirection() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.indirection_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
A_Indirection::_internal_mutable_indirection() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.indirection_;
}

// -------------------------------------------------------------------

// A_ArrayExpr

// repeated .pg_query.Node elements = 1 [json_name = "elements"];
inline int A_ArrayExpr::_internal_elements_size() const {
  return _internal_elements().size();
}
inline int A_ArrayExpr::elements_size() const {
  return _internal_elements_size();
}
inline void A_ArrayExpr::clear_elements() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.elements_.Clear();
}
inline ::pg_query::Node* A_ArrayExpr::mutable_elements(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.A_ArrayExpr.elements)
  return _internal_mutable_elements()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* A_ArrayExpr::mutable_elements()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.A_ArrayExpr.elements)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_elements();
}
inline const ::pg_query::Node& A_ArrayExpr::elements(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.A_ArrayExpr.elements)
  return _internal_elements().Get(index);
}
inline ::pg_query::Node* A_ArrayExpr::add_elements() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_elements()->Add();
  // @@protoc_insertion_point(field_add:pg_query.A_ArrayExpr.elements)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& A_ArrayExpr::elements() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.A_ArrayExpr.elements)
  return _internal_elements();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
A_ArrayExpr::_internal_elements() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.elements_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
A_ArrayExpr::_internal_mutable_elements() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.elements_;
}

// int32 location = 2 [json_name = "location"];
inline void A_ArrayExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t A_ArrayExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.A_ArrayExpr.location)
  return _internal_location();
}
inline void A_ArrayExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.A_ArrayExpr.location)
}
inline ::int32_t A_ArrayExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void A_ArrayExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// ResTarget

// string name = 1 [json_name = "name"];
inline void ResTarget::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& ResTarget::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ResTarget.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ResTarget::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ResTarget.name)
}
inline std::string* ResTarget::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.ResTarget.name)
  return _s;
}
inline const std::string& ResTarget::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void ResTarget::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* ResTarget::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* ResTarget::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ResTarget.name)
  return _impl_.name_.Release();
}
inline void ResTarget::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_indirection().size();
}
inline int ResTarget::indirection_size() const {
  return _internal_indirection_size();
}
inline void ResTarget::clear_indirection() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indirection_.Clear();
}
inline ::pg_query::Node* ResTarget::mutable_indirection(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ResTarget.indirection)
  return _internal_mutable_indirection()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ResTarget::mutable_indirection()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ResTarget.indirection)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_indirection();
}
inline const ::pg_query::Node& ResTarget::indirection(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ResTarget.indirection)
  return _internal_indirection().Get(index);
}
inline ::pg_query::Node* ResTarget::add_indirection() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_indirection()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ResTarget.indirection)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ResTarget::indirection() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ResTarget.indirection)
  return _internal_indirection();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ResTarget::_internal_indirection() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.indirection_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ResTarget::_internal_mutable_indirection() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.indirection_;
}

// .pg_query.Node val = 3 [json_name = "val"];
inline bool ResTarget::has_val() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.val_ != nullptr);
  return value;
}
inline void ResTarget::clear_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.val_ != nullptr) _impl_.val_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& ResTarget::_internal_val() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.val_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ResTarget::val() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ResTarget.val)
  return _internal_val();
}
inline void ResTarget::unsafe_arena_set_allocated_val(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.val_);
  }
  _impl_.val_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ResTarget.val)
}
inline ::pg_query::Node* ResTarget::release_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.val_;
  _impl_.val_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ResTarget::unsafe_arena_release_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ResTarget.val)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.val_;
  _impl_.val_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ResTarget::_internal_mutable_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.val_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.val_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.val_;
}
inline ::pg_query::Node* ResTarget::mutable_val() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_val();
  // @@protoc_insertion_point(field_mutable:pg_query.ResTarget.val)
  return _msg;
}
inline void ResTarget::set_allocated_val(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.val_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.val_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ResTarget.val)
}

// int32 location = 4 [json_name = "location"];
inline void ResTarget::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t ResTarget::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ResTarget.location)
  return _internal_location();
}
inline void ResTarget::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ResTarget.location)
}
inline ::int32_t ResTarget::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void ResTarget::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// MultiAssignRef

// .pg_query.Node source = 1 [json_name = "source"];
inline bool MultiAssignRef::has_source() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.source_ != nullptr);
  return value;
}
inline void MultiAssignRef::clear_source() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.source_ != nullptr) _impl_.source_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& MultiAssignRef::_internal_source() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.source_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& MultiAssignRef::source() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MultiAssignRef.source)
  return _internal_source();
}
inline void MultiAssignRef::unsafe_arena_set_allocated_source(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.source_);
  }
  _impl_.source_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MultiAssignRef.source)
}
inline ::pg_query::Node* MultiAssignRef::release_source() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.source_;
  _impl_.source_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* MultiAssignRef::unsafe_arena_release_source() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.MultiAssignRef.source)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.source_;
  _impl_.source_ = nullptr;
  return temp;
}
inline ::pg_query::Node* MultiAssignRef::_internal_mutable_source() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.source_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.source_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.source_;
}
inline ::pg_query::Node* MultiAssignRef::mutable_source() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_source();
  // @@protoc_insertion_point(field_mutable:pg_query.MultiAssignRef.source)
  return _msg;
}
inline void MultiAssignRef::set_allocated_source(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.source_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.source_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.MultiAssignRef.source)
}

// int32 colno = 2 [json_name = "colno"];
inline void MultiAssignRef::clear_colno() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.colno_ = 0;
}
inline ::int32_t MultiAssignRef::colno() const {
  // @@protoc_insertion_point(field_get:pg_query.MultiAssignRef.colno)
  return _internal_colno();
}
inline void MultiAssignRef::set_colno(::int32_t value) {
  _internal_set_colno(value);
  // @@protoc_insertion_point(field_set:pg_query.MultiAssignRef.colno)
}
inline ::int32_t MultiAssignRef::_internal_colno() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.colno_;
}
inline void MultiAssignRef::_internal_set_colno(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.colno_ = value;
}

// int32 ncolumns = 3 [json_name = "ncolumns"];
inline void MultiAssignRef::clear_ncolumns() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ncolumns_ = 0;
}
inline ::int32_t MultiAssignRef::ncolumns() const {
  // @@protoc_insertion_point(field_get:pg_query.MultiAssignRef.ncolumns)
  return _internal_ncolumns();
}
inline void MultiAssignRef::set_ncolumns(::int32_t value) {
  _internal_set_ncolumns(value);
  // @@protoc_insertion_point(field_set:pg_query.MultiAssignRef.ncolumns)
}
inline ::int32_t MultiAssignRef::_internal_ncolumns() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ncolumns_;
}
inline void MultiAssignRef::_internal_set_ncolumns(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ncolumns_ = value;
}

// -------------------------------------------------------------------

// SortBy

// .pg_query.Node node = 1 [json_name = "node"];
inline bool SortBy::has_node() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.node_ != nullptr);
  return value;
}
inline void SortBy::clear_node() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.node_ != nullptr) _impl_.node_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& SortBy::_internal_node() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.node_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SortBy::node() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SortBy.node)
  return _internal_node();
}
inline void SortBy::unsafe_arena_set_allocated_node(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.node_);
  }
  _impl_.node_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SortBy.node)
}
inline ::pg_query::Node* SortBy::release_node() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.node_;
  _impl_.node_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SortBy::unsafe_arena_release_node() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SortBy.node)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.node_;
  _impl_.node_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SortBy::_internal_mutable_node() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.node_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.node_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.node_;
}
inline ::pg_query::Node* SortBy::mutable_node() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_node();
  // @@protoc_insertion_point(field_mutable:pg_query.SortBy.node)
  return _msg;
}
inline void SortBy::set_allocated_node(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.node_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.node_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.sortby_dir_ = 0;
}
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::set_sortby_dir(::pg_query::SortByDir value) {
  _internal_set_sortby_dir(value);
  // @@protoc_insertion_point(field_set:pg_query.SortBy.sortby_dir)
}
inline ::pg_query::SortByDir SortBy::_internal_sortby_dir() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::SortByDir>(_impl_.sortby_dir_);
}
inline void SortBy::_internal_set_sortby_dir(::pg_query::SortByDir value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.sortby_dir_ = value;
}

// .pg_query.SortByNulls sortby_nulls = 3 [json_name = "sortby_nulls"];
inline void SortBy::clear_sortby_nulls() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.sortby_nulls_ = 0;
}
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::set_sortby_nulls(::pg_query::SortByNulls value) {
  _internal_set_sortby_nulls(value);
  // @@protoc_insertion_point(field_set:pg_query.SortBy.sortby_nulls)
}
inline ::pg_query::SortByNulls SortBy::_internal_sortby_nulls() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::SortByNulls>(_impl_.sortby_nulls_);
}
inline void SortBy::_internal_set_sortby_nulls(::pg_query::SortByNulls value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.sortby_nulls_ = value;
}

// repeated .pg_query.Node use_op = 4 [json_name = "useOp"];
inline int SortBy::_internal_use_op_size() const {
  return _internal_use_op().size();
}
inline int SortBy::use_op_size() const {
  return _internal_use_op_size();
}
inline void SortBy::clear_use_op() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.use_op_.Clear();
}
inline ::pg_query::Node* SortBy::mutable_use_op(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SortBy.use_op)
  return _internal_mutable_use_op()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SortBy::mutable_use_op()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SortBy.use_op)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_use_op();
}
inline const ::pg_query::Node& SortBy::use_op(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SortBy.use_op)
  return _internal_use_op().Get(index);
}
inline ::pg_query::Node* SortBy::add_use_op() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_use_op()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SortBy.use_op)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SortBy::use_op() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SortBy.use_op)
  return _internal_use_op();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SortBy::_internal_use_op() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.use_op_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SortBy::_internal_mutable_use_op() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.use_op_;
}

// int32 location = 5 [json_name = "location"];
inline void SortBy::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t SortBy::location() const {
  // @@protoc_insertion_point(field_get:pg_query.SortBy.location)
  return _internal_location();
}
inline void SortBy::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.SortBy.location)
}
inline ::int32_t SortBy::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void SortBy::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// WindowDef

// string name = 1 [json_name = "name"];
inline void WindowDef::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& WindowDef::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void WindowDef::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.WindowDef.name)
}
inline std::string* WindowDef::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.name)
  return _s;
}
inline const std::string& WindowDef::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void WindowDef::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* WindowDef::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* WindowDef::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WindowDef.name)
  return _impl_.name_.Release();
}
inline void WindowDef::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowDef.name)
}

// string refname = 2 [json_name = "refname"];
inline void WindowDef::clear_refname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.refname_.ClearToEmpty();
}
inline const std::string& WindowDef::refname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.refname)
  return _internal_refname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void WindowDef::set_refname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.refname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.WindowDef.refname)
}
inline std::string* WindowDef::mutable_refname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_refname();
  // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.refname)
  return _s;
}
inline const std::string& WindowDef::_internal_refname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.refname_.Get();
}
inline void WindowDef::_internal_set_refname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.refname_.Set(value, GetArena());
}
inline std::string* WindowDef::_internal_mutable_refname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.refname_.Mutable( GetArena());
}
inline std::string* WindowDef::release_refname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WindowDef.refname)
  return _impl_.refname_.Release();
}
inline void WindowDef::set_allocated_refname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.refname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.refname_.IsDefault()) {
          _impl_.refname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_partition_clause().size();
}
inline int WindowDef::partition_clause_size() const {
  return _internal_partition_clause_size();
}
inline void WindowDef::clear_partition_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.partition_clause_.Clear();
}
inline ::pg_query::Node* WindowDef::mutable_partition_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.partition_clause)
  return _internal_mutable_partition_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* WindowDef::mutable_partition_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WindowDef.partition_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_partition_clause();
}
inline const ::pg_query::Node& WindowDef::partition_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.partition_clause)
  return _internal_partition_clause().Get(index);
}
inline ::pg_query::Node* WindowDef::add_partition_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_partition_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.WindowDef.partition_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& WindowDef::partition_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.WindowDef.partition_clause)
  return _internal_partition_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
WindowDef::_internal_partition_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.partition_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
WindowDef::_internal_mutable_partition_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.partition_clause_;
}

// repeated .pg_query.Node order_clause = 4 [json_name = "orderClause"];
inline int WindowDef::_internal_order_clause_size() const {
  return _internal_order_clause().size();
}
inline int WindowDef::order_clause_size() const {
  return _internal_order_clause_size();
}
inline void WindowDef::clear_order_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.order_clause_.Clear();
}
inline ::pg_query::Node* WindowDef::mutable_order_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.order_clause)
  return _internal_mutable_order_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* WindowDef::mutable_order_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WindowDef.order_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_order_clause();
}
inline const ::pg_query::Node& WindowDef::order_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.order_clause)
  return _internal_order_clause().Get(index);
}
inline ::pg_query::Node* WindowDef::add_order_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_order_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.WindowDef.order_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& WindowDef::order_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.WindowDef.order_clause)
  return _internal_order_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
WindowDef::_internal_order_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.order_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
WindowDef::_internal_mutable_order_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.order_clause_;
}

// int32 frame_options = 5 [json_name = "frameOptions"];
inline void WindowDef::clear_frame_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.frame_options_ = 0;
}
inline ::int32_t WindowDef::frame_options() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.frame_options)
  return _internal_frame_options();
}
inline void WindowDef::set_frame_options(::int32_t value) {
  _internal_set_frame_options(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowDef.frame_options)
}
inline ::int32_t WindowDef::_internal_frame_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.frame_options_;
}
inline void WindowDef::_internal_set_frame_options(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.frame_options_ = value;
}

// .pg_query.Node start_offset = 6 [json_name = "startOffset"];
inline bool WindowDef::has_start_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.start_offset_ != nullptr);
  return value;
}
inline void WindowDef::clear_start_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.start_offset_ != nullptr) _impl_.start_offset_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& WindowDef::_internal_start_offset() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.start_offset_);
  }
  _impl_.start_offset_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowDef.start_offset)
}
inline ::pg_query::Node* WindowDef::release_start_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.start_offset_;
  _impl_.start_offset_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* WindowDef::unsafe_arena_release_start_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WindowDef.start_offset)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.start_offset_;
  _impl_.start_offset_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WindowDef::_internal_mutable_start_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.start_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.start_offset_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.start_offset_;
}
inline ::pg_query::Node* WindowDef::mutable_start_offset() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_start_offset();
  // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.start_offset)
  return _msg;
}
inline void WindowDef::set_allocated_start_offset(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.start_offset_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.start_offset_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowDef.start_offset)
}

// .pg_query.Node end_offset = 7 [json_name = "endOffset"];
inline bool WindowDef::has_end_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.end_offset_ != nullptr);
  return value;
}
inline void WindowDef::clear_end_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.end_offset_ != nullptr) _impl_.end_offset_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& WindowDef::_internal_end_offset() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.end_offset_);
  }
  _impl_.end_offset_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowDef.end_offset)
}
inline ::pg_query::Node* WindowDef::release_end_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.end_offset_;
  _impl_.end_offset_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* WindowDef::unsafe_arena_release_end_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WindowDef.end_offset)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.end_offset_;
  _impl_.end_offset_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WindowDef::_internal_mutable_end_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.end_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.end_offset_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.end_offset_;
}
inline ::pg_query::Node* WindowDef::mutable_end_offset() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_end_offset();
  // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.end_offset)
  return _msg;
}
inline void WindowDef::set_allocated_end_offset(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.end_offset_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.end_offset_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowDef.end_offset)
}

// int32 location = 8 [json_name = "location"];
inline void WindowDef::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t WindowDef::location() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowDef.location)
  return _internal_location();
}
inline void WindowDef::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowDef.location)
}
inline ::int32_t WindowDef::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void WindowDef::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// RangeSubselect

// bool lateral = 1 [json_name = "lateral"];
inline void RangeSubselect::clear_lateral() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.lateral_ = false;
}
inline bool RangeSubselect::lateral() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeSubselect.lateral)
  return _internal_lateral();
}
inline void RangeSubselect::set_lateral(bool value) {
  _internal_set_lateral(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeSubselect.lateral)
}
inline bool RangeSubselect::_internal_lateral() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.lateral_;
}
inline void RangeSubselect::_internal_set_lateral(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.lateral_ = value;
}

// .pg_query.Node subquery = 2 [json_name = "subquery"];
inline bool RangeSubselect::has_subquery() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.subquery_ != nullptr);
  return value;
}
inline void RangeSubselect::clear_subquery() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.subquery_ != nullptr) _impl_.subquery_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& RangeSubselect::_internal_subquery() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.subquery_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeSubselect::subquery() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeSubselect.subquery)
  return _internal_subquery();
}
inline void RangeSubselect::unsafe_arena_set_allocated_subquery(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.subquery_);
  }
  _impl_.subquery_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeSubselect.subquery)
}
inline ::pg_query::Node* RangeSubselect::release_subquery() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.subquery_;
  _impl_.subquery_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RangeSubselect::unsafe_arena_release_subquery() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeSubselect.subquery)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.subquery_;
  _impl_.subquery_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeSubselect::_internal_mutable_subquery() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.subquery_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.subquery_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.subquery_;
}
inline ::pg_query::Node* RangeSubselect::mutable_subquery() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_subquery();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeSubselect.subquery)
  return _msg;
}
inline void RangeSubselect::set_allocated_subquery(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.subquery_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.subquery_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeSubselect.subquery)
}

// .pg_query.Alias alias = 3 [json_name = "alias"];
inline bool RangeSubselect::has_alias() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.alias_ != nullptr);
  return value;
}
inline void RangeSubselect::clear_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.alias_ != nullptr) _impl_.alias_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Alias& RangeSubselect::_internal_alias() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Alias* p = _impl_.alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeSubselect::alias() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeSubselect.alias)
  return _internal_alias();
}
inline void RangeSubselect::unsafe_arena_set_allocated_alias(::pg_query::Alias* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.alias_);
  }
  _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeSubselect.alias)
}
inline ::pg_query::Alias* RangeSubselect::release_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Alias* released = _impl_.alias_;
  _impl_.alias_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Alias* RangeSubselect::unsafe_arena_release_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeSubselect.alias)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Alias* temp = _impl_.alias_;
  _impl_.alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeSubselect::_internal_mutable_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(p);
  }
  return _impl_.alias_;
}
inline ::pg_query::Alias* RangeSubselect::mutable_alias() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Alias* _msg = _internal_mutable_alias();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeSubselect.alias)
  return _msg;
}
inline void RangeSubselect::set_allocated_alias(::pg_query::Alias* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Alias*>(_impl_.alias_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Alias*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeSubselect.alias)
}

// -------------------------------------------------------------------

// RangeFunction

// bool lateral = 1 [json_name = "lateral"];
inline void RangeFunction::clear_lateral() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.lateral_ = false;
}
inline bool RangeFunction::lateral() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeFunction.lateral)
  return _internal_lateral();
}
inline void RangeFunction::set_lateral(bool value) {
  _internal_set_lateral(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeFunction.lateral)
}
inline bool RangeFunction::_internal_lateral() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.lateral_;
}
inline void RangeFunction::_internal_set_lateral(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.lateral_ = value;
}

// bool ordinality = 2 [json_name = "ordinality"];
inline void RangeFunction::clear_ordinality() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ordinality_ = false;
}
inline bool RangeFunction::ordinality() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeFunction.ordinality)
  return _internal_ordinality();
}
inline void RangeFunction::set_ordinality(bool value) {
  _internal_set_ordinality(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeFunction.ordinality)
}
inline bool RangeFunction::_internal_ordinality() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ordinality_;
}
inline void RangeFunction::_internal_set_ordinality(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ordinality_ = value;
}

// bool is_rowsfrom = 3 [json_name = "is_rowsfrom"];
inline void RangeFunction::clear_is_rowsfrom() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_rowsfrom_ = false;
}
inline bool RangeFunction::is_rowsfrom() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeFunction.is_rowsfrom)
  return _internal_is_rowsfrom();
}
inline void RangeFunction::set_is_rowsfrom(bool value) {
  _internal_set_is_rowsfrom(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeFunction.is_rowsfrom)
}
inline bool RangeFunction::_internal_is_rowsfrom() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_rowsfrom_;
}
inline void RangeFunction::_internal_set_is_rowsfrom(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_rowsfrom_ = value;
}

// repeated .pg_query.Node functions = 4 [json_name = "functions"];
inline int RangeFunction::_internal_functions_size() const {
  return _internal_functions().size();
}
inline int RangeFunction::functions_size() const {
  return _internal_functions_size();
}
inline void RangeFunction::clear_functions() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.functions_.Clear();
}
inline ::pg_query::Node* RangeFunction::mutable_functions(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeFunction.functions)
  return _internal_mutable_functions()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeFunction::mutable_functions()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeFunction.functions)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_functions();
}
inline const ::pg_query::Node& RangeFunction::functions(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeFunction.functions)
  return _internal_functions().Get(index);
}
inline ::pg_query::Node* RangeFunction::add_functions() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_functions()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeFunction.functions)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeFunction::functions() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeFunction.functions)
  return _internal_functions();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeFunction::_internal_functions() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.functions_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeFunction::_internal_mutable_functions() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.functions_;
}

// .pg_query.Alias alias = 5 [json_name = "alias"];
inline bool RangeFunction::has_alias() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.alias_ != nullptr);
  return value;
}
inline void RangeFunction::clear_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.alias_ != nullptr) _impl_.alias_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Alias& RangeFunction::_internal_alias() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Alias* p = _impl_.alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeFunction::alias() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeFunction.alias)
  return _internal_alias();
}
inline void RangeFunction::unsafe_arena_set_allocated_alias(::pg_query::Alias* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.alias_);
  }
  _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeFunction.alias)
}
inline ::pg_query::Alias* RangeFunction::release_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Alias* released = _impl_.alias_;
  _impl_.alias_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Alias* RangeFunction::unsafe_arena_release_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeFunction.alias)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Alias* temp = _impl_.alias_;
  _impl_.alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeFunction::_internal_mutable_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(p);
  }
  return _impl_.alias_;
}
inline ::pg_query::Alias* RangeFunction::mutable_alias() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Alias* _msg = _internal_mutable_alias();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeFunction.alias)
  return _msg;
}
inline void RangeFunction::set_allocated_alias(::pg_query::Alias* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Alias*>(_impl_.alias_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Alias*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  // @@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 _internal_coldeflist().size();
}
inline int RangeFunction::coldeflist_size() const {
  return _internal_coldeflist_size();
}
inline void RangeFunction::clear_coldeflist() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coldeflist_.Clear();
}
inline ::pg_query::Node* RangeFunction::mutable_coldeflist(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeFunction.coldeflist)
  return _internal_mutable_coldeflist()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeFunction::mutable_coldeflist()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeFunction.coldeflist)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_coldeflist();
}
inline const ::pg_query::Node& RangeFunction::coldeflist(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeFunction.coldeflist)
  return _internal_coldeflist().Get(index);
}
inline ::pg_query::Node* RangeFunction::add_coldeflist() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_coldeflist()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeFunction.coldeflist)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeFunction::coldeflist() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeFunction.coldeflist)
  return _internal_coldeflist();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeFunction::_internal_coldeflist() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.coldeflist_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeFunction::_internal_mutable_coldeflist() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.coldeflist_;
}

// -------------------------------------------------------------------

// RangeTableFunc

// bool lateral = 1 [json_name = "lateral"];
inline void RangeTableFunc::clear_lateral() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.lateral_ = false;
}
inline bool RangeTableFunc::lateral() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.lateral)
  return _internal_lateral();
}
inline void RangeTableFunc::set_lateral(bool value) {
  _internal_set_lateral(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableFunc.lateral)
}
inline bool RangeTableFunc::_internal_lateral() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.lateral_;
}
inline void RangeTableFunc::_internal_set_lateral(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.lateral_ = value;
}

// .pg_query.Node docexpr = 2 [json_name = "docexpr"];
inline bool RangeTableFunc::has_docexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.docexpr_ != nullptr);
  return value;
}
inline void RangeTableFunc::clear_docexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.docexpr_ != nullptr) _impl_.docexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& RangeTableFunc::_internal_docexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.docexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTableFunc::docexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.docexpr)
  return _internal_docexpr();
}
inline void RangeTableFunc::unsafe_arena_set_allocated_docexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.docexpr_);
  }
  _impl_.docexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFunc.docexpr)
}
inline ::pg_query::Node* RangeTableFunc::release_docexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.docexpr_;
  _impl_.docexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RangeTableFunc::unsafe_arena_release_docexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFunc.docexpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.docexpr_;
  _impl_.docexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTableFunc::_internal_mutable_docexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.docexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.docexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.docexpr_;
}
inline ::pg_query::Node* RangeTableFunc::mutable_docexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_docexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFunc.docexpr)
  return _msg;
}
inline void RangeTableFunc::set_allocated_docexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.docexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.docexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFunc.docexpr)
}

// .pg_query.Node rowexpr = 3 [json_name = "rowexpr"];
inline bool RangeTableFunc::has_rowexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.rowexpr_ != nullptr);
  return value;
}
inline void RangeTableFunc::clear_rowexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.rowexpr_ != nullptr) _impl_.rowexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& RangeTableFunc::_internal_rowexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.rowexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTableFunc::rowexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.rowexpr)
  return _internal_rowexpr();
}
inline void RangeTableFunc::unsafe_arena_set_allocated_rowexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.rowexpr_);
  }
  _impl_.rowexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFunc.rowexpr)
}
inline ::pg_query::Node* RangeTableFunc::release_rowexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.rowexpr_;
  _impl_.rowexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RangeTableFunc::unsafe_arena_release_rowexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFunc.rowexpr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.rowexpr_;
  _impl_.rowexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTableFunc::_internal_mutable_rowexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.rowexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.rowexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.rowexpr_;
}
inline ::pg_query::Node* RangeTableFunc::mutable_rowexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_rowexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFunc.rowexpr)
  return _msg;
}
inline void RangeTableFunc::set_allocated_rowexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.rowexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.rowexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_namespaces().size();
}
inline int RangeTableFunc::namespaces_size() const {
  return _internal_namespaces_size();
}
inline void RangeTableFunc::clear_namespaces() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.namespaces_.Clear();
}
inline ::pg_query::Node* RangeTableFunc::mutable_namespaces(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFunc.namespaces)
  return _internal_mutable_namespaces()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTableFunc::mutable_namespaces()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTableFunc.namespaces)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_namespaces();
}
inline const ::pg_query::Node& RangeTableFunc::namespaces(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.namespaces)
  return _internal_namespaces().Get(index);
}
inline ::pg_query::Node* RangeTableFunc::add_namespaces() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_namespaces()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTableFunc.namespaces)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTableFunc::namespaces() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTableFunc.namespaces)
  return _internal_namespaces();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTableFunc::_internal_namespaces() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.namespaces_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTableFunc::_internal_mutable_namespaces() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.namespaces_;
}

// repeated .pg_query.Node columns = 5 [json_name = "columns"];
inline int RangeTableFunc::_internal_columns_size() const {
  return _internal_columns().size();
}
inline int RangeTableFunc::columns_size() const {
  return _internal_columns_size();
}
inline void RangeTableFunc::clear_columns() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.columns_.Clear();
}
inline ::pg_query::Node* RangeTableFunc::mutable_columns(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFunc.columns)
  return _internal_mutable_columns()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTableFunc::mutable_columns()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTableFunc.columns)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_columns();
}
inline const ::pg_query::Node& RangeTableFunc::columns(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.columns)
  return _internal_columns().Get(index);
}
inline ::pg_query::Node* RangeTableFunc::add_columns() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_columns()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTableFunc.columns)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTableFunc::columns() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTableFunc.columns)
  return _internal_columns();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTableFunc::_internal_columns() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.columns_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTableFunc::_internal_mutable_columns() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.columns_;
}

// .pg_query.Alias alias = 6 [json_name = "alias"];
inline bool RangeTableFunc::has_alias() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.alias_ != nullptr);
  return value;
}
inline void RangeTableFunc::clear_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.alias_ != nullptr) _impl_.alias_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Alias& RangeTableFunc::_internal_alias() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Alias* p = _impl_.alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeTableFunc::alias() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.alias)
  return _internal_alias();
}
inline void RangeTableFunc::unsafe_arena_set_allocated_alias(::pg_query::Alias* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.alias_);
  }
  _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFunc.alias)
}
inline ::pg_query::Alias* RangeTableFunc::release_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Alias* released = _impl_.alias_;
  _impl_.alias_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Alias* RangeTableFunc::unsafe_arena_release_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFunc.alias)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Alias* temp = _impl_.alias_;
  _impl_.alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeTableFunc::_internal_mutable_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(p);
  }
  return _impl_.alias_;
}
inline ::pg_query::Alias* RangeTableFunc::mutable_alias() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Alias* _msg = _internal_mutable_alias();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFunc.alias)
  return _msg;
}
inline void RangeTableFunc::set_allocated_alias(::pg_query::Alias* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Alias*>(_impl_.alias_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Alias*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFunc.alias)
}

// int32 location = 7 [json_name = "location"];
inline void RangeTableFunc::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t RangeTableFunc::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.location)
  return _internal_location();
}
inline void RangeTableFunc::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableFunc.location)
}
inline ::int32_t RangeTableFunc::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void RangeTableFunc::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// RangeTableFuncCol

// string colname = 1 [json_name = "colname"];
inline void RangeTableFuncCol::clear_colname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.colname_.ClearToEmpty();
}
inline const std::string& RangeTableFuncCol::colname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.colname)
  return _internal_colname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RangeTableFuncCol::set_colname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.colname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.RangeTableFuncCol.colname)
}
inline std::string* RangeTableFuncCol::mutable_colname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_colname();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFuncCol.colname)
  return _s;
}
inline const std::string& RangeTableFuncCol::_internal_colname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.colname_.Get();
}
inline void RangeTableFuncCol::_internal_set_colname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.colname_.Set(value, GetArena());
}
inline std::string* RangeTableFuncCol::_internal_mutable_colname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.colname_.Mutable( GetArena());
}
inline std::string* RangeTableFuncCol::release_colname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFuncCol.colname)
  return _impl_.colname_.Release();
}
inline void RangeTableFuncCol::set_allocated_colname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.colname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.colname_.IsDefault()) {
          _impl_.colname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFuncCol.colname)
}

// .pg_query.TypeName type_name = 2 [json_name = "typeName"];
inline bool RangeTableFuncCol::has_type_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.type_name_ != nullptr);
  return value;
}
inline void RangeTableFuncCol::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.type_name_ != nullptr) _impl_.type_name_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::TypeName& RangeTableFuncCol::_internal_type_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_name_);
  }
  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFuncCol.type_name)
}
inline ::pg_query::TypeName* RangeTableFuncCol::release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* released = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* RangeTableFuncCol::unsafe_arena_release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFuncCol.type_name)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* temp = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* RangeTableFuncCol::_internal_mutable_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.type_name_;
}
inline ::pg_query::TypeName* RangeTableFuncCol::mutable_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_type_name();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFuncCol.type_name)
  return _msg;
}
inline void RangeTableFuncCol::set_allocated_type_name(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.type_name_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.for_ordinality_ = false;
}
inline bool RangeTableFuncCol::for_ordinality() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.for_ordinality)
  return _internal_for_ordinality();
}
inline void RangeTableFuncCol::set_for_ordinality(bool value) {
  _internal_set_for_ordinality(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableFuncCol.for_ordinality)
}
inline bool RangeTableFuncCol::_internal_for_ordinality() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.for_ordinality_;
}
inline void RangeTableFuncCol::_internal_set_for_ordinality(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.for_ordinality_ = value;
}

// bool is_not_null = 4 [json_name = "is_not_null"];
inline void RangeTableFuncCol::clear_is_not_null() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_not_null_ = false;
}
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::set_is_not_null(bool value) {
  _internal_set_is_not_null(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableFuncCol.is_not_null)
}
inline bool RangeTableFuncCol::_internal_is_not_null() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_not_null_;
}
inline void RangeTableFuncCol::_internal_set_is_not_null(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_not_null_ = value;
}

// .pg_query.Node colexpr = 5 [json_name = "colexpr"];
inline bool RangeTableFuncCol::has_colexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.colexpr_ != nullptr);
  return value;
}
inline void RangeTableFuncCol::clear_colexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.colexpr_ != nullptr) _impl_.colexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& RangeTableFuncCol::_internal_colexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.colexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTableFuncCol::colexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.colexpr)
  return _internal_colexpr();
}
inline void RangeTableFuncCol::unsafe_arena_set_allocated_colexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.colexpr_);
  }
  _impl_.colexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFuncCol.colexpr)
}
inline ::pg_query::Node* RangeTableFuncCol::release_colexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.colexpr_;
  _impl_.colexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RangeTableFuncCol::unsafe_arena_release_colexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFuncCol.colexpr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.colexpr_;
  _impl_.colexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTableFuncCol::_internal_mutable_colexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.colexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.colexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.colexpr_;
}
inline ::pg_query::Node* RangeTableFuncCol::mutable_colexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_colexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFuncCol.colexpr)
  return _msg;
}
inline void RangeTableFuncCol::set_allocated_colexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.colexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.colexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFuncCol.colexpr)
}

// .pg_query.Node coldefexpr = 6 [json_name = "coldefexpr"];
inline bool RangeTableFuncCol::has_coldefexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.coldefexpr_ != nullptr);
  return value;
}
inline void RangeTableFuncCol::clear_coldefexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.coldefexpr_ != nullptr) _impl_.coldefexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& RangeTableFuncCol::_internal_coldefexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.coldefexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTableFuncCol::coldefexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.coldefexpr)
  return _internal_coldefexpr();
}
inline void RangeTableFuncCol::unsafe_arena_set_allocated_coldefexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.coldefexpr_);
  }
  _impl_.coldefexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFuncCol.coldefexpr)
}
inline ::pg_query::Node* RangeTableFuncCol::release_coldefexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.coldefexpr_;
  _impl_.coldefexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RangeTableFuncCol::unsafe_arena_release_coldefexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTableFuncCol.coldefexpr)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.coldefexpr_;
  _impl_.coldefexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTableFuncCol::_internal_mutable_coldefexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.coldefexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.coldefexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.coldefexpr_;
}
inline ::pg_query::Node* RangeTableFuncCol::mutable_coldefexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_coldefexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFuncCol.coldefexpr)
  return _msg;
}
inline void RangeTableFuncCol::set_allocated_coldefexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.coldefexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.coldefexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFuncCol.coldefexpr)
}

// int32 location = 7 [json_name = "location"];
inline void RangeTableFuncCol::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t RangeTableFuncCol::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.location)
  return _internal_location();
}
inline void RangeTableFuncCol::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableFuncCol.location)
}
inline ::int32_t RangeTableFuncCol::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void RangeTableFuncCol::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// RangeTableSample

// .pg_query.Node relation = 1 [json_name = "relation"];
inline bool RangeTableSample::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void RangeTableSample::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& RangeTableSample::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTableSample::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.relation)
  return _internal_relation();
}
inline void RangeTableSample::unsafe_arena_set_allocated_relation(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableSample.relation)
}
inline ::pg_query::Node* RangeTableSample::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RangeTableSample::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTableSample.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTableSample::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::Node* RangeTableSample::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableSample.relation)
  return _msg;
}
inline void RangeTableSample::set_allocated_relation(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_method().size();
}
inline int RangeTableSample::method_size() const {
  return _internal_method_size();
}
inline void RangeTableSample::clear_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.method_.Clear();
}
inline ::pg_query::Node* RangeTableSample::mutable_method(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableSample.method)
  return _internal_mutable_method()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTableSample::mutable_method()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTableSample.method)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_method();
}
inline const ::pg_query::Node& RangeTableSample::method(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.method)
  return _internal_method().Get(index);
}
inline ::pg_query::Node* RangeTableSample::add_method() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_method()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTableSample.method)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTableSample::method() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTableSample.method)
  return _internal_method();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTableSample::_internal_method() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.method_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTableSample::_internal_mutable_method() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.method_;
}

// repeated .pg_query.Node args = 3 [json_name = "args"];
inline int RangeTableSample::_internal_args_size() const {
  return _internal_args().size();
}
inline int RangeTableSample::args_size() const {
  return _internal_args_size();
}
inline void RangeTableSample::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* RangeTableSample::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableSample.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTableSample::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTableSample.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& RangeTableSample::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* RangeTableSample::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTableSample.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTableSample::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTableSample.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTableSample::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTableSample::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// .pg_query.Node repeatable = 4 [json_name = "repeatable"];
inline bool RangeTableSample::has_repeatable() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.repeatable_ != nullptr);
  return value;
}
inline void RangeTableSample::clear_repeatable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.repeatable_ != nullptr) _impl_.repeatable_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& RangeTableSample::_internal_repeatable() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.repeatable_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTableSample::repeatable() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.repeatable)
  return _internal_repeatable();
}
inline void RangeTableSample::unsafe_arena_set_allocated_repeatable(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.repeatable_);
  }
  _impl_.repeatable_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableSample.repeatable)
}
inline ::pg_query::Node* RangeTableSample::release_repeatable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.repeatable_;
  _impl_.repeatable_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RangeTableSample::unsafe_arena_release_repeatable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTableSample.repeatable)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.repeatable_;
  _impl_.repeatable_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTableSample::_internal_mutable_repeatable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.repeatable_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.repeatable_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.repeatable_;
}
inline ::pg_query::Node* RangeTableSample::mutable_repeatable() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_repeatable();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTableSample.repeatable)
  return _msg;
}
inline void RangeTableSample::set_allocated_repeatable(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.repeatable_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.repeatable_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableSample.repeatable)
}

// int32 location = 5 [json_name = "location"];
inline void RangeTableSample::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t RangeTableSample::location() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.location)
  return _internal_location();
}
inline void RangeTableSample::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTableSample.location)
}
inline ::int32_t RangeTableSample::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void RangeTableSample::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// ColumnDef

// string colname = 1 [json_name = "colname"];
inline void ColumnDef::clear_colname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.colname_.ClearToEmpty();
}
inline const std::string& ColumnDef::colname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.colname)
  return _internal_colname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ColumnDef::set_colname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.colname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.colname)
}
inline std::string* ColumnDef::mutable_colname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_colname();
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.colname)
  return _s;
}
inline const std::string& ColumnDef::_internal_colname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.colname_.Get();
}
inline void ColumnDef::_internal_set_colname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.colname_.Set(value, GetArena());
}
inline std::string* ColumnDef::_internal_mutable_colname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.colname_.Mutable( GetArena());
}
inline std::string* ColumnDef::release_colname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.colname)
  return _impl_.colname_.Release();
}
inline void ColumnDef::set_allocated_colname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.colname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.colname_.IsDefault()) {
          _impl_.colname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.colname)
}

// .pg_query.TypeName type_name = 2 [json_name = "typeName"];
inline bool ColumnDef::has_type_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.type_name_ != nullptr);
  return value;
}
inline void ColumnDef::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.type_name_ != nullptr) _impl_.type_name_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::TypeName& ColumnDef::_internal_type_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_name_);
  }
  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.type_name)
}
inline ::pg_query::TypeName* ColumnDef::release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* released = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* ColumnDef::unsafe_arena_release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.type_name)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* temp = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* ColumnDef::_internal_mutable_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.type_name_;
}
inline ::pg_query::TypeName* ColumnDef::mutable_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_type_name();
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.type_name)
  return _msg;
}
inline void ColumnDef::set_allocated_type_name(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.type_name_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.type_name)
}

// string compression = 3 [json_name = "compression"];
inline void ColumnDef::clear_compression() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.compression_.ClearToEmpty();
}
inline const std::string& ColumnDef::compression() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.compression)
  return _internal_compression();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ColumnDef::set_compression(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.compression_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.compression)
}
inline std::string* ColumnDef::mutable_compression() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_compression();
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.compression)
  return _s;
}
inline const std::string& ColumnDef::_internal_compression() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.compression_.Get();
}
inline void ColumnDef::_internal_set_compression(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.compression_.Set(value, GetArena());
}
inline std::string* ColumnDef::_internal_mutable_compression() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.compression_.Mutable( GetArena());
}
inline std::string* ColumnDef::release_compression() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.compression)
  return _impl_.compression_.Release();
}
inline void ColumnDef::set_allocated_compression(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.compression_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.compression_.IsDefault()) {
          _impl_.compression_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.compression)
}

// int32 inhcount = 4 [json_name = "inhcount"];
inline void ColumnDef::clear_inhcount() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inhcount_ = 0;
}
inline ::int32_t ColumnDef::inhcount() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.inhcount)
  return _internal_inhcount();
}
inline void ColumnDef::set_inhcount(::int32_t value) {
  _internal_set_inhcount(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.inhcount)
}
inline ::int32_t ColumnDef::_internal_inhcount() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inhcount_;
}
inline void ColumnDef::_internal_set_inhcount(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inhcount_ = value;
}

// bool is_local = 5 [json_name = "is_local"];
inline void ColumnDef::clear_is_local() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_local_ = false;
}
inline bool ColumnDef::is_local() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.is_local)
  return _internal_is_local();
}
inline void ColumnDef::set_is_local(bool value) {
  _internal_set_is_local(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.is_local)
}
inline bool ColumnDef::_internal_is_local() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_local_;
}
inline void ColumnDef::_internal_set_is_local(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_local_ = value;
}

// bool is_not_null = 6 [json_name = "is_not_null"];
inline void ColumnDef::clear_is_not_null() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_not_null_ = false;
}
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::set_is_not_null(bool value) {
  _internal_set_is_not_null(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.is_not_null)
}
inline bool ColumnDef::_internal_is_not_null() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_not_null_;
}
inline void ColumnDef::_internal_set_is_not_null(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_not_null_ = value;
}

// bool is_from_type = 7 [json_name = "is_from_type"];
inline void ColumnDef::clear_is_from_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_from_type_ = false;
}
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::set_is_from_type(bool value) {
  _internal_set_is_from_type(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.is_from_type)
}
inline bool ColumnDef::_internal_is_from_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_from_type_;
}
inline void ColumnDef::_internal_set_is_from_type(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_from_type_ = value;
}

// string storage = 8 [json_name = "storage"];
inline void ColumnDef::clear_storage() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.storage_.ClearToEmpty();
}
inline const std::string& ColumnDef::storage() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.storage)
  return _internal_storage();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ColumnDef::set_storage(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.storage_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.storage)
}
inline std::string* ColumnDef::mutable_storage() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_storage();
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.storage)
  return _s;
}
inline const std::string& ColumnDef::_internal_storage() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.storage_.Get();
}
inline void ColumnDef::_internal_set_storage(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.storage_.Set(value, GetArena());
}
inline std::string* ColumnDef::_internal_mutable_storage() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.storage_.Mutable( GetArena());
}
inline std::string* ColumnDef::release_storage() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.storage)
  return _impl_.storage_.Release();
}
inline void ColumnDef::set_allocated_storage(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.storage_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.storage_.IsDefault()) {
          _impl_.storage_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.storage)
}

// string storage_name = 9 [json_name = "storage_name"];
inline void ColumnDef::clear_storage_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.storage_name_.ClearToEmpty();
}
inline const std::string& ColumnDef::storage_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.storage_name)
  return _internal_storage_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ColumnDef::set_storage_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.storage_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.storage_name)
}
inline std::string* ColumnDef::mutable_storage_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_storage_name();
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.storage_name)
  return _s;
}
inline const std::string& ColumnDef::_internal_storage_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.storage_name_.Get();
}
inline void ColumnDef::_internal_set_storage_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.storage_name_.Set(value, GetArena());
}
inline std::string* ColumnDef::_internal_mutable_storage_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.storage_name_.Mutable( GetArena());
}
inline std::string* ColumnDef::release_storage_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.storage_name)
  return _impl_.storage_name_.Release();
}
inline void ColumnDef::set_allocated_storage_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.storage_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.storage_name_.IsDefault()) {
          _impl_.storage_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.storage_name)
}

// .pg_query.Node raw_default = 10 [json_name = "raw_default"];
inline bool ColumnDef::has_raw_default() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.raw_default_ != nullptr);
  return value;
}
inline void ColumnDef::clear_raw_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.raw_default_ != nullptr) _impl_.raw_default_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& ColumnDef::_internal_raw_default() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.raw_default_);
  }
  _impl_.raw_default_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.raw_default)
}
inline ::pg_query::Node* ColumnDef::release_raw_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.raw_default_;
  _impl_.raw_default_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ColumnDef::unsafe_arena_release_raw_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.raw_default)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.raw_default_;
  _impl_.raw_default_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ColumnDef::_internal_mutable_raw_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.raw_default_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.raw_default_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.raw_default_;
}
inline ::pg_query::Node* ColumnDef::mutable_raw_default() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_raw_default();
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.raw_default)
  return _msg;
}
inline void ColumnDef::set_allocated_raw_default(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.raw_default_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.raw_default_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.raw_default)
}

// .pg_query.Node cooked_default = 11 [json_name = "cooked_default"];
inline bool ColumnDef::has_cooked_default() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cooked_default_ != nullptr);
  return value;
}
inline void ColumnDef::clear_cooked_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.cooked_default_ != nullptr) _impl_.cooked_default_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& ColumnDef::_internal_cooked_default() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cooked_default_);
  }
  _impl_.cooked_default_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.cooked_default)
}
inline ::pg_query::Node* ColumnDef::release_cooked_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.cooked_default_;
  _impl_.cooked_default_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ColumnDef::unsafe_arena_release_cooked_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.cooked_default)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.cooked_default_;
  _impl_.cooked_default_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ColumnDef::_internal_mutable_cooked_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.cooked_default_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.cooked_default_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.cooked_default_;
}
inline ::pg_query::Node* ColumnDef::mutable_cooked_default() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_cooked_default();
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.cooked_default)
  return _msg;
}
inline void ColumnDef::set_allocated_cooked_default(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.cooked_default_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.cooked_default_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.cooked_default)
}

// string identity = 12 [json_name = "identity"];
inline void ColumnDef::clear_identity() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.identity_.ClearToEmpty();
}
inline const std::string& ColumnDef::identity() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.identity)
  return _internal_identity();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ColumnDef::set_identity(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.identity_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.identity)
}
inline std::string* ColumnDef::mutable_identity() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_identity();
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.identity)
  return _s;
}
inline const std::string& ColumnDef::_internal_identity() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.identity_.Get();
}
inline void ColumnDef::_internal_set_identity(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.identity_.Set(value, GetArena());
}
inline std::string* ColumnDef::_internal_mutable_identity() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.identity_.Mutable( GetArena());
}
inline std::string* ColumnDef::release_identity() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.identity)
  return _impl_.identity_.Release();
}
inline void ColumnDef::set_allocated_identity(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.identity_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.identity_.IsDefault()) {
          _impl_.identity_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.identity)
}

// .pg_query.RangeVar identity_sequence = 13 [json_name = "identitySequence"];
inline bool ColumnDef::has_identity_sequence() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.identity_sequence_ != nullptr);
  return value;
}
inline void ColumnDef::clear_identity_sequence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.identity_sequence_ != nullptr) _impl_.identity_sequence_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::pg_query::RangeVar& ColumnDef::_internal_identity_sequence() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.identity_sequence_);
  }
  _impl_.identity_sequence_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.identity_sequence)
}
inline ::pg_query::RangeVar* ColumnDef::release_identity_sequence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::RangeVar* released = _impl_.identity_sequence_;
  _impl_.identity_sequence_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* ColumnDef::unsafe_arena_release_identity_sequence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.identity_sequence)

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::RangeVar* temp = _impl_.identity_sequence_;
  _impl_.identity_sequence_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* ColumnDef::_internal_mutable_identity_sequence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.identity_sequence_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.identity_sequence_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.identity_sequence_;
}
inline ::pg_query::RangeVar* ColumnDef::mutable_identity_sequence() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_identity_sequence();
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.identity_sequence)
  return _msg;
}
inline void ColumnDef::set_allocated_identity_sequence(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.identity_sequence_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }

  _impl_.identity_sequence_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.identity_sequence)
}

// string generated = 14 [json_name = "generated"];
inline void ColumnDef::clear_generated() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.generated_.ClearToEmpty();
}
inline const std::string& ColumnDef::generated() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.generated)
  return _internal_generated();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ColumnDef::set_generated(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.generated_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.generated)
}
inline std::string* ColumnDef::mutable_generated() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_generated();
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.generated)
  return _s;
}
inline const std::string& ColumnDef::_internal_generated() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.generated_.Get();
}
inline void ColumnDef::_internal_set_generated(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.generated_.Set(value, GetArena());
}
inline std::string* ColumnDef::_internal_mutable_generated() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.generated_.Mutable( GetArena());
}
inline std::string* ColumnDef::release_generated() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.generated)
  return _impl_.generated_.Release();
}
inline void ColumnDef::set_allocated_generated(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.generated_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.generated_.IsDefault()) {
          _impl_.generated_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.generated)
}

// .pg_query.CollateClause coll_clause = 15 [json_name = "collClause"];
inline bool ColumnDef::has_coll_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.coll_clause_ != nullptr);
  return value;
}
inline void ColumnDef::clear_coll_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.coll_clause_ != nullptr) _impl_.coll_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::pg_query::CollateClause& ColumnDef::_internal_coll_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::CollateClause* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.coll_clause_);
  }
  _impl_.coll_clause_ = reinterpret_cast<::pg_query::CollateClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.coll_clause)
}
inline ::pg_query::CollateClause* ColumnDef::release_coll_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000010u;
  ::pg_query::CollateClause* released = _impl_.coll_clause_;
  _impl_.coll_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::CollateClause* ColumnDef::unsafe_arena_release_coll_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ColumnDef.coll_clause)

  _impl_._has_bits_[0] &= ~0x00000010u;
  ::pg_query::CollateClause* temp = _impl_.coll_clause_;
  _impl_.coll_clause_ = nullptr;
  return temp;
}
inline ::pg_query::CollateClause* ColumnDef::_internal_mutable_coll_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.coll_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::CollateClause>(GetArena());
    _impl_.coll_clause_ = reinterpret_cast<::pg_query::CollateClause*>(p);
  }
  return _impl_.coll_clause_;
}
inline ::pg_query::CollateClause* ColumnDef::mutable_coll_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CollateClause* _msg = _internal_mutable_coll_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.coll_clause)
  return _msg;
}
inline void ColumnDef::set_allocated_coll_clause(::pg_query::CollateClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::CollateClause*>(_impl_.coll_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::CollateClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }

  _impl_.coll_clause_ = reinterpret_cast<::pg_query::CollateClause*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.coll_clause)
}

// uint32 coll_oid = 16 [json_name = "collOid"];
inline void ColumnDef::clear_coll_oid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coll_oid_ = 0u;
}
inline ::uint32_t ColumnDef::coll_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.coll_oid)
  return _internal_coll_oid();
}
inline void ColumnDef::set_coll_oid(::uint32_t value) {
  _internal_set_coll_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.coll_oid)
}
inline ::uint32_t ColumnDef::_internal_coll_oid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.coll_oid_;
}
inline void ColumnDef::_internal_set_coll_oid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.coll_oid_ = value;
}

// repeated .pg_query.Node constraints = 17 [json_name = "constraints"];
inline int ColumnDef::_internal_constraints_size() const {
  return _internal_constraints().size();
}
inline int ColumnDef::constraints_size() const {
  return _internal_constraints_size();
}
inline void ColumnDef::clear_constraints() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.constraints_.Clear();
}
inline ::pg_query::Node* ColumnDef::mutable_constraints(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.constraints)
  return _internal_mutable_constraints()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ColumnDef::mutable_constraints()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ColumnDef.constraints)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_constraints();
}
inline const ::pg_query::Node& ColumnDef::constraints(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.constraints)
  return _internal_constraints().Get(index);
}
inline ::pg_query::Node* ColumnDef::add_constraints() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_constraints()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ColumnDef.constraints)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ColumnDef::constraints() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ColumnDef.constraints)
  return _internal_constraints();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ColumnDef::_internal_constraints() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.constraints_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ColumnDef::_internal_mutable_constraints() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.constraints_;
}

// repeated .pg_query.Node fdwoptions = 18 [json_name = "fdwoptions"];
inline int ColumnDef::_internal_fdwoptions_size() const {
  return _internal_fdwoptions().size();
}
inline int ColumnDef::fdwoptions_size() const {
  return _internal_fdwoptions_size();
}
inline void ColumnDef::clear_fdwoptions() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fdwoptions_.Clear();
}
inline ::pg_query::Node* ColumnDef::mutable_fdwoptions(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.fdwoptions)
  return _internal_mutable_fdwoptions()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ColumnDef::mutable_fdwoptions()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ColumnDef.fdwoptions)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_fdwoptions();
}
inline const ::pg_query::Node& ColumnDef::fdwoptions(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.fdwoptions)
  return _internal_fdwoptions().Get(index);
}
inline ::pg_query::Node* ColumnDef::add_fdwoptions() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_fdwoptions()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ColumnDef.fdwoptions)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ColumnDef::fdwoptions() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ColumnDef.fdwoptions)
  return _internal_fdwoptions();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ColumnDef::_internal_fdwoptions() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fdwoptions_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ColumnDef::_internal_mutable_fdwoptions() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.fdwoptions_;
}

// int32 location = 19 [json_name = "location"];
inline void ColumnDef::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t ColumnDef::location() const {
  // @@protoc_insertion_point(field_get:pg_query.ColumnDef.location)
  return _internal_location();
}
inline void ColumnDef::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.ColumnDef.location)
}
inline ::int32_t ColumnDef::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void ColumnDef::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// TableLikeClause

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool TableLikeClause::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void TableLikeClause::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& TableLikeClause::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& TableLikeClause::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableLikeClause.relation)
  return _internal_relation();
}
inline void TableLikeClause::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TableLikeClause.relation)
}
inline ::pg_query::RangeVar* TableLikeClause::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* TableLikeClause::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.TableLikeClause.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* TableLikeClause::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* TableLikeClause::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.TableLikeClause.relation)
  return _msg;
}
inline void TableLikeClause::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.TableLikeClause.relation)
}

// uint32 options = 2 [json_name = "options"];
inline void TableLikeClause::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_ = 0u;
}
inline ::uint32_t TableLikeClause::options() const {
  // @@protoc_insertion_point(field_get:pg_query.TableLikeClause.options)
  return _internal_options();
}
inline void TableLikeClause::set_options(::uint32_t value) {
  _internal_set_options(value);
  // @@protoc_insertion_point(field_set:pg_query.TableLikeClause.options)
}
inline ::uint32_t TableLikeClause::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline void TableLikeClause::_internal_set_options(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.options_ = value;
}

// uint32 relation_oid = 3 [json_name = "relationOid"];
inline void TableLikeClause::clear_relation_oid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relation_oid_ = 0u;
}
inline ::uint32_t TableLikeClause::relation_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.TableLikeClause.relation_oid)
  return _internal_relation_oid();
}
inline void TableLikeClause::set_relation_oid(::uint32_t value) {
  _internal_set_relation_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.TableLikeClause.relation_oid)
}
inline ::uint32_t TableLikeClause::_internal_relation_oid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.relation_oid_;
}
inline void TableLikeClause::_internal_set_relation_oid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relation_oid_ = value;
}

// -------------------------------------------------------------------

// IndexElem

// string name = 1 [json_name = "name"];
inline void IndexElem::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& IndexElem::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void IndexElem::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.IndexElem.name)
}
inline std::string* IndexElem::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.name)
  return _s;
}
inline const std::string& IndexElem::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void IndexElem::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* IndexElem::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* IndexElem::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IndexElem.name)
  return _impl_.name_.Release();
}
inline void IndexElem::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexElem.name)
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool IndexElem::has_expr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.expr_ != nullptr);
  return value;
}
inline void IndexElem::clear_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.expr_ != nullptr) _impl_.expr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& IndexElem::_internal_expr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& IndexElem::expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.expr)
  return _internal_expr();
}
inline void IndexElem::unsafe_arena_set_allocated_expr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.expr_);
  }
  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IndexElem.expr)
}
inline ::pg_query::Node* IndexElem::release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.expr_;
  _impl_.expr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* IndexElem::unsafe_arena_release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IndexElem.expr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.expr_;
  _impl_.expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* IndexElem::_internal_mutable_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.expr_;
}
inline ::pg_query::Node* IndexElem::mutable_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.expr)
  return _msg;
}
inline void IndexElem::set_allocated_expr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.expr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexElem.expr)
}

// string indexcolname = 3 [json_name = "indexcolname"];
inline void IndexElem::clear_indexcolname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indexcolname_.ClearToEmpty();
}
inline const std::string& IndexElem::indexcolname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.indexcolname)
  return _internal_indexcolname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void IndexElem::set_indexcolname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.indexcolname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.IndexElem.indexcolname)
}
inline std::string* IndexElem::mutable_indexcolname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_indexcolname();
  // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.indexcolname)
  return _s;
}
inline const std::string& IndexElem::_internal_indexcolname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.indexcolname_.Get();
}
inline void IndexElem::_internal_set_indexcolname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.indexcolname_.Set(value, GetArena());
}
inline std::string* IndexElem::_internal_mutable_indexcolname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.indexcolname_.Mutable( GetArena());
}
inline std::string* IndexElem::release_indexcolname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IndexElem.indexcolname)
  return _impl_.indexcolname_.Release();
}
inline void IndexElem::set_allocated_indexcolname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indexcolname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.indexcolname_.IsDefault()) {
          _impl_.indexcolname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_collation().size();
}
inline int IndexElem::collation_size() const {
  return _internal_collation_size();
}
inline void IndexElem::clear_collation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.collation_.Clear();
}
inline ::pg_query::Node* IndexElem::mutable_collation(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.collation)
  return _internal_mutable_collation()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* IndexElem::mutable_collation()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexElem.collation)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_collation();
}
inline const ::pg_query::Node& IndexElem::collation(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.collation)
  return _internal_collation().Get(index);
}
inline ::pg_query::Node* IndexElem::add_collation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_collation()->Add();
  // @@protoc_insertion_point(field_add:pg_query.IndexElem.collation)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& IndexElem::collation() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.IndexElem.collation)
  return _internal_collation();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
IndexElem::_internal_collation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.collation_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
IndexElem::_internal_mutable_collation() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.collation_;
}

// repeated .pg_query.Node opclass = 5 [json_name = "opclass"];
inline int IndexElem::_internal_opclass_size() const {
  return _internal_opclass().size();
}
inline int IndexElem::opclass_size() const {
  return _internal_opclass_size();
}
inline void IndexElem::clear_opclass() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opclass_.Clear();
}
inline ::pg_query::Node* IndexElem::mutable_opclass(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.opclass)
  return _internal_mutable_opclass()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* IndexElem::mutable_opclass()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexElem.opclass)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_opclass();
}
inline const ::pg_query::Node& IndexElem::opclass(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.opclass)
  return _internal_opclass().Get(index);
}
inline ::pg_query::Node* IndexElem::add_opclass() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_opclass()->Add();
  // @@protoc_insertion_point(field_add:pg_query.IndexElem.opclass)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& IndexElem::opclass() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.IndexElem.opclass)
  return _internal_opclass();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
IndexElem::_internal_opclass() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opclass_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
IndexElem::_internal_mutable_opclass() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.opclass_;
}

// repeated .pg_query.Node opclassopts = 6 [json_name = "opclassopts"];
inline int IndexElem::_internal_opclassopts_size() const {
  return _internal_opclassopts().size();
}
inline int IndexElem::opclassopts_size() const {
  return _internal_opclassopts_size();
}
inline void IndexElem::clear_opclassopts() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opclassopts_.Clear();
}
inline ::pg_query::Node* IndexElem::mutable_opclassopts(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.opclassopts)
  return _internal_mutable_opclassopts()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* IndexElem::mutable_opclassopts()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexElem.opclassopts)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_opclassopts();
}
inline const ::pg_query::Node& IndexElem::opclassopts(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.opclassopts)
  return _internal_opclassopts().Get(index);
}
inline ::pg_query::Node* IndexElem::add_opclassopts() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_opclassopts()->Add();
  // @@protoc_insertion_point(field_add:pg_query.IndexElem.opclassopts)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& IndexElem::opclassopts() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.IndexElem.opclassopts)
  return _internal_opclassopts();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
IndexElem::_internal_opclassopts() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opclassopts_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
IndexElem::_internal_mutable_opclassopts() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.opclassopts_;
}

// .pg_query.SortByDir ordering = 7 [json_name = "ordering"];
inline void IndexElem::clear_ordering() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ordering_ = 0;
}
inline ::pg_query::SortByDir IndexElem::ordering() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexElem.ordering)
  return _internal_ordering();
}
inline void IndexElem::set_ordering(::pg_query::SortByDir value) {
  _internal_set_ordering(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexElem.ordering)
}
inline ::pg_query::SortByDir IndexElem::_internal_ordering() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::SortByDir>(_impl_.ordering_);
}
inline void IndexElem::_internal_set_ordering(::pg_query::SortByDir value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ordering_ = value;
}

// .pg_query.SortByNulls nulls_ordering = 8 [json_name = "nulls_ordering"];
inline void IndexElem::clear_nulls_ordering() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.nulls_ordering_ = 0;
}
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::set_nulls_ordering(::pg_query::SortByNulls value) {
  _internal_set_nulls_ordering(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexElem.nulls_ordering)
}
inline ::pg_query::SortByNulls IndexElem::_internal_nulls_ordering() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::SortByNulls>(_impl_.nulls_ordering_);
}
inline void IndexElem::_internal_set_nulls_ordering(::pg_query::SortByNulls value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.nulls_ordering_ = value;
}

// -------------------------------------------------------------------

// DefElem

// string defnamespace = 1 [json_name = "defnamespace"];
inline void DefElem::clear_defnamespace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.defnamespace_.ClearToEmpty();
}
inline const std::string& DefElem::defnamespace() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DefElem.defnamespace)
  return _internal_defnamespace();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DefElem::set_defnamespace(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.defnamespace_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.DefElem.defnamespace)
}
inline std::string* DefElem::mutable_defnamespace() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_defnamespace();
  // @@protoc_insertion_point(field_mutable:pg_query.DefElem.defnamespace)
  return _s;
}
inline const std::string& DefElem::_internal_defnamespace() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.defnamespace_.Get();
}
inline void DefElem::_internal_set_defnamespace(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.defnamespace_.Set(value, GetArena());
}
inline std::string* DefElem::_internal_mutable_defnamespace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.defnamespace_.Mutable( GetArena());
}
inline std::string* DefElem::release_defnamespace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DefElem.defnamespace)
  return _impl_.defnamespace_.Release();
}
inline void DefElem::set_allocated_defnamespace(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.defnamespace_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.defnamespace_.IsDefault()) {
          _impl_.defnamespace_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.DefElem.defnamespace)
}

// string defname = 2 [json_name = "defname"];
inline void DefElem::clear_defname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.defname_.ClearToEmpty();
}
inline const std::string& DefElem::defname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DefElem.defname)
  return _internal_defname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DefElem::set_defname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.defname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.DefElem.defname)
}
inline std::string* DefElem::mutable_defname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_defname();
  // @@protoc_insertion_point(field_mutable:pg_query.DefElem.defname)
  return _s;
}
inline const std::string& DefElem::_internal_defname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.defname_.Get();
}
inline void DefElem::_internal_set_defname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.defname_.Set(value, GetArena());
}
inline std::string* DefElem::_internal_mutable_defname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.defname_.Mutable( GetArena());
}
inline std::string* DefElem::release_defname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DefElem.defname)
  return _impl_.defname_.Release();
}
inline void DefElem::set_allocated_defname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.defname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.defname_.IsDefault()) {
          _impl_.defname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.DefElem.defname)
}

// .pg_query.Node arg = 3 [json_name = "arg"];
inline bool DefElem::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void DefElem::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& DefElem::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& DefElem::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DefElem.arg)
  return _internal_arg();
}
inline void DefElem::unsafe_arena_set_allocated_arg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DefElem.arg)
}
inline ::pg_query::Node* DefElem::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* DefElem::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DefElem.arg)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* DefElem::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::Node* DefElem::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.DefElem.arg)
  return _msg;
}
inline void DefElem::set_allocated_arg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.DefElem.arg)
}

// .pg_query.DefElemAction defaction = 4 [json_name = "defaction"];
inline void DefElem::clear_defaction() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.defaction_ = 0;
}
inline ::pg_query::DefElemAction DefElem::defaction() const {
  // @@protoc_insertion_point(field_get:pg_query.DefElem.defaction)
  return _internal_defaction();
}
inline void DefElem::set_defaction(::pg_query::DefElemAction value) {
  _internal_set_defaction(value);
  // @@protoc_insertion_point(field_set:pg_query.DefElem.defaction)
}
inline ::pg_query::DefElemAction DefElem::_internal_defaction() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::DefElemAction>(_impl_.defaction_);
}
inline void DefElem::_internal_set_defaction(::pg_query::DefElemAction value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.defaction_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void DefElem::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t DefElem::location() const {
  // @@protoc_insertion_point(field_get:pg_query.DefElem.location)
  return _internal_location();
}
inline void DefElem::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.DefElem.location)
}
inline ::int32_t DefElem::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void DefElem::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// LockingClause

// repeated .pg_query.Node locked_rels = 1 [json_name = "lockedRels"];
inline int LockingClause::_internal_locked_rels_size() const {
  return _internal_locked_rels().size();
}
inline int LockingClause::locked_rels_size() const {
  return _internal_locked_rels_size();
}
inline void LockingClause::clear_locked_rels() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.locked_rels_.Clear();
}
inline ::pg_query::Node* LockingClause::mutable_locked_rels(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.LockingClause.locked_rels)
  return _internal_mutable_locked_rels()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* LockingClause::mutable_locked_rels()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.LockingClause.locked_rels)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_locked_rels();
}
inline const ::pg_query::Node& LockingClause::locked_rels(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.LockingClause.locked_rels)
  return _internal_locked_rels().Get(index);
}
inline ::pg_query::Node* LockingClause::add_locked_rels() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_locked_rels()->Add();
  // @@protoc_insertion_point(field_add:pg_query.LockingClause.locked_rels)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& LockingClause::locked_rels() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.LockingClause.locked_rels)
  return _internal_locked_rels();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
LockingClause::_internal_locked_rels() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.locked_rels_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
LockingClause::_internal_mutable_locked_rels() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.locked_rels_;
}

// .pg_query.LockClauseStrength strength = 2 [json_name = "strength"];
inline void LockingClause::clear_strength() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.strength_ = 0;
}
inline ::pg_query::LockClauseStrength LockingClause::strength() const {
  // @@protoc_insertion_point(field_get:pg_query.LockingClause.strength)
  return _internal_strength();
}
inline void LockingClause::set_strength(::pg_query::LockClauseStrength value) {
  _internal_set_strength(value);
  // @@protoc_insertion_point(field_set:pg_query.LockingClause.strength)
}
inline ::pg_query::LockClauseStrength LockingClause::_internal_strength() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::LockClauseStrength>(_impl_.strength_);
}
inline void LockingClause::_internal_set_strength(::pg_query::LockClauseStrength value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.strength_ = value;
}

// .pg_query.LockWaitPolicy wait_policy = 3 [json_name = "waitPolicy"];
inline void LockingClause::clear_wait_policy() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.wait_policy_ = 0;
}
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::set_wait_policy(::pg_query::LockWaitPolicy value) {
  _internal_set_wait_policy(value);
  // @@protoc_insertion_point(field_set:pg_query.LockingClause.wait_policy)
}
inline ::pg_query::LockWaitPolicy LockingClause::_internal_wait_policy() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::LockWaitPolicy>(_impl_.wait_policy_);
}
inline void LockingClause::_internal_set_wait_policy(::pg_query::LockWaitPolicy value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.wait_policy_ = value;
}

// -------------------------------------------------------------------

// XmlSerialize

// .pg_query.XmlOptionType xmloption = 1 [json_name = "xmloption"];
inline void XmlSerialize::clear_xmloption() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.xmloption_ = 0;
}
inline ::pg_query::XmlOptionType XmlSerialize::xmloption() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlSerialize.xmloption)
  return _internal_xmloption();
}
inline void XmlSerialize::set_xmloption(::pg_query::XmlOptionType value) {
  _internal_set_xmloption(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlSerialize.xmloption)
}
inline ::pg_query::XmlOptionType XmlSerialize::_internal_xmloption() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::XmlOptionType>(_impl_.xmloption_);
}
inline void XmlSerialize::_internal_set_xmloption(::pg_query::XmlOptionType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.xmloption_ = value;
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool XmlSerialize::has_expr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.expr_ != nullptr);
  return value;
}
inline void XmlSerialize::clear_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.expr_ != nullptr) _impl_.expr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& XmlSerialize::_internal_expr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& XmlSerialize::expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.XmlSerialize.expr)
  return _internal_expr();
}
inline void XmlSerialize::unsafe_arena_set_allocated_expr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.expr_);
  }
  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.XmlSerialize.expr)
}
inline ::pg_query::Node* XmlSerialize::release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.expr_;
  _impl_.expr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* XmlSerialize::unsafe_arena_release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.XmlSerialize.expr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.expr_;
  _impl_.expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* XmlSerialize::_internal_mutable_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.expr_;
}
inline ::pg_query::Node* XmlSerialize::mutable_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.XmlSerialize.expr)
  return _msg;
}
inline void XmlSerialize::set_allocated_expr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.expr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.XmlSerialize.expr)
}

// .pg_query.TypeName type_name = 3 [json_name = "typeName"];
inline bool XmlSerialize::has_type_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.type_name_ != nullptr);
  return value;
}
inline void XmlSerialize::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.type_name_ != nullptr) _impl_.type_name_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::TypeName& XmlSerialize::_internal_type_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_name_);
  }
  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.XmlSerialize.type_name)
}
inline ::pg_query::TypeName* XmlSerialize::release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::TypeName* released = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* XmlSerialize::unsafe_arena_release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.XmlSerialize.type_name)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::TypeName* temp = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* XmlSerialize::_internal_mutable_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.type_name_;
}
inline ::pg_query::TypeName* XmlSerialize::mutable_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_type_name();
  // @@protoc_insertion_point(field_mutable:pg_query.XmlSerialize.type_name)
  return _msg;
}
inline void XmlSerialize::set_allocated_type_name(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.type_name_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.XmlSerialize.type_name)
}

// bool indent = 4 [json_name = "indent"];
inline void XmlSerialize::clear_indent() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indent_ = false;
}
inline bool XmlSerialize::indent() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlSerialize.indent)
  return _internal_indent();
}
inline void XmlSerialize::set_indent(bool value) {
  _internal_set_indent(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlSerialize.indent)
}
inline bool XmlSerialize::_internal_indent() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.indent_;
}
inline void XmlSerialize::_internal_set_indent(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.indent_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void XmlSerialize::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t XmlSerialize::location() const {
  // @@protoc_insertion_point(field_get:pg_query.XmlSerialize.location)
  return _internal_location();
}
inline void XmlSerialize::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.XmlSerialize.location)
}
inline ::int32_t XmlSerialize::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void XmlSerialize::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// PartitionElem

// string name = 1 [json_name = "name"];
inline void PartitionElem::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& PartitionElem::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PartitionElem.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void PartitionElem::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.PartitionElem.name)
}
inline std::string* PartitionElem::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionElem.name)
  return _s;
}
inline const std::string& PartitionElem::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void PartitionElem::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* PartitionElem::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* PartitionElem::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PartitionElem.name)
  return _impl_.name_.Release();
}
inline void PartitionElem::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionElem.name)
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool PartitionElem::has_expr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.expr_ != nullptr);
  return value;
}
inline void PartitionElem::clear_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.expr_ != nullptr) _impl_.expr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& PartitionElem::_internal_expr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& PartitionElem::expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PartitionElem.expr)
  return _internal_expr();
}
inline void PartitionElem::unsafe_arena_set_allocated_expr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.expr_);
  }
  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PartitionElem.expr)
}
inline ::pg_query::Node* PartitionElem::release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.expr_;
  _impl_.expr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* PartitionElem::unsafe_arena_release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PartitionElem.expr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.expr_;
  _impl_.expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* PartitionElem::_internal_mutable_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.expr_;
}
inline ::pg_query::Node* PartitionElem::mutable_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionElem.expr)
  return _msg;
}
inline void PartitionElem::set_allocated_expr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.expr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_collation().size();
}
inline int PartitionElem::collation_size() const {
  return _internal_collation_size();
}
inline void PartitionElem::clear_collation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.collation_.Clear();
}
inline ::pg_query::Node* PartitionElem::mutable_collation(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionElem.collation)
  return _internal_mutable_collation()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* PartitionElem::mutable_collation()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionElem.collation)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_collation();
}
inline const ::pg_query::Node& PartitionElem::collation(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PartitionElem.collation)
  return _internal_collation().Get(index);
}
inline ::pg_query::Node* PartitionElem::add_collation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_collation()->Add();
  // @@protoc_insertion_point(field_add:pg_query.PartitionElem.collation)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& PartitionElem::collation() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.PartitionElem.collation)
  return _internal_collation();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
PartitionElem::_internal_collation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.collation_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
PartitionElem::_internal_mutable_collation() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.collation_;
}

// repeated .pg_query.Node opclass = 4 [json_name = "opclass"];
inline int PartitionElem::_internal_opclass_size() const {
  return _internal_opclass().size();
}
inline int PartitionElem::opclass_size() const {
  return _internal_opclass_size();
}
inline void PartitionElem::clear_opclass() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opclass_.Clear();
}
inline ::pg_query::Node* PartitionElem::mutable_opclass(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionElem.opclass)
  return _internal_mutable_opclass()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* PartitionElem::mutable_opclass()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionElem.opclass)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_opclass();
}
inline const ::pg_query::Node& PartitionElem::opclass(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PartitionElem.opclass)
  return _internal_opclass().Get(index);
}
inline ::pg_query::Node* PartitionElem::add_opclass() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_opclass()->Add();
  // @@protoc_insertion_point(field_add:pg_query.PartitionElem.opclass)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& PartitionElem::opclass() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.PartitionElem.opclass)
  return _internal_opclass();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
PartitionElem::_internal_opclass() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opclass_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
PartitionElem::_internal_mutable_opclass() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.opclass_;
}

// int32 location = 5 [json_name = "location"];
inline void PartitionElem::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t PartitionElem::location() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionElem.location)
  return _internal_location();
}
inline void PartitionElem::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionElem.location)
}
inline ::int32_t PartitionElem::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void PartitionElem::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// PartitionSpec

// .pg_query.PartitionStrategy strategy = 1 [json_name = "strategy"];
inline void PartitionSpec::clear_strategy() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.strategy_ = 0;
}
inline ::pg_query::PartitionStrategy PartitionSpec::strategy() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionSpec.strategy)
  return _internal_strategy();
}
inline void PartitionSpec::set_strategy(::pg_query::PartitionStrategy value) {
  _internal_set_strategy(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionSpec.strategy)
}
inline ::pg_query::PartitionStrategy PartitionSpec::_internal_strategy() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::PartitionStrategy>(_impl_.strategy_);
}
inline void PartitionSpec::_internal_set_strategy(::pg_query::PartitionStrategy value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.strategy_ = value;
}

// repeated .pg_query.Node part_params = 2 [json_name = "partParams"];
inline int PartitionSpec::_internal_part_params_size() const {
  return _internal_part_params().size();
}
inline int PartitionSpec::part_params_size() const {
  return _internal_part_params_size();
}
inline void PartitionSpec::clear_part_params() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.part_params_.Clear();
}
inline ::pg_query::Node* PartitionSpec::mutable_part_params(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionSpec.part_params)
  return _internal_mutable_part_params()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* PartitionSpec::mutable_part_params()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionSpec.part_params)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_part_params();
}
inline const ::pg_query::Node& PartitionSpec::part_params(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PartitionSpec.part_params)
  return _internal_part_params().Get(index);
}
inline ::pg_query::Node* PartitionSpec::add_part_params() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_part_params()->Add();
  // @@protoc_insertion_point(field_add:pg_query.PartitionSpec.part_params)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& PartitionSpec::part_params() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.PartitionSpec.part_params)
  return _internal_part_params();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
PartitionSpec::_internal_part_params() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.part_params_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
PartitionSpec::_internal_mutable_part_params() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.part_params_;
}

// int32 location = 3 [json_name = "location"];
inline void PartitionSpec::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t PartitionSpec::location() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionSpec.location)
  return _internal_location();
}
inline void PartitionSpec::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionSpec.location)
}
inline ::int32_t PartitionSpec::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void PartitionSpec::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// PartitionBoundSpec

// string strategy = 1 [json_name = "strategy"];
inline void PartitionBoundSpec::clear_strategy() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.strategy_.ClearToEmpty();
}
inline const std::string& PartitionBoundSpec::strategy() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.strategy)
  return _internal_strategy();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void PartitionBoundSpec::set_strategy(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.strategy_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.strategy)
}
inline std::string* PartitionBoundSpec::mutable_strategy() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_strategy();
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionBoundSpec.strategy)
  return _s;
}
inline const std::string& PartitionBoundSpec::_internal_strategy() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.strategy_.Get();
}
inline void PartitionBoundSpec::_internal_set_strategy(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.strategy_.Set(value, GetArena());
}
inline std::string* PartitionBoundSpec::_internal_mutable_strategy() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.strategy_.Mutable( GetArena());
}
inline std::string* PartitionBoundSpec::release_strategy() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PartitionBoundSpec.strategy)
  return _impl_.strategy_.Release();
}
inline void PartitionBoundSpec::set_allocated_strategy(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.strategy_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.strategy_.IsDefault()) {
          _impl_.strategy_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionBoundSpec.strategy)
}

// bool is_default = 2 [json_name = "is_default"];
inline void PartitionBoundSpec::clear_is_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_default_ = false;
}
inline bool PartitionBoundSpec::is_default() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.is_default)
  return _internal_is_default();
}
inline void PartitionBoundSpec::set_is_default(bool value) {
  _internal_set_is_default(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.is_default)
}
inline bool PartitionBoundSpec::_internal_is_default() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_default_;
}
inline void PartitionBoundSpec::_internal_set_is_default(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_default_ = value;
}

// int32 modulus = 3 [json_name = "modulus"];
inline void PartitionBoundSpec::clear_modulus() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.modulus_ = 0;
}
inline ::int32_t PartitionBoundSpec::modulus() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.modulus)
  return _internal_modulus();
}
inline void PartitionBoundSpec::set_modulus(::int32_t value) {
  _internal_set_modulus(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.modulus)
}
inline ::int32_t PartitionBoundSpec::_internal_modulus() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.modulus_;
}
inline void PartitionBoundSpec::_internal_set_modulus(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.modulus_ = value;
}

// int32 remainder = 4 [json_name = "remainder"];
inline void PartitionBoundSpec::clear_remainder() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.remainder_ = 0;
}
inline ::int32_t PartitionBoundSpec::remainder() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.remainder)
  return _internal_remainder();
}
inline void PartitionBoundSpec::set_remainder(::int32_t value) {
  _internal_set_remainder(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.remainder)
}
inline ::int32_t PartitionBoundSpec::_internal_remainder() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.remainder_;
}
inline void PartitionBoundSpec::_internal_set_remainder(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.remainder_ = value;
}

// repeated .pg_query.Node listdatums = 5 [json_name = "listdatums"];
inline int PartitionBoundSpec::_internal_listdatums_size() const {
  return _internal_listdatums().size();
}
inline int PartitionBoundSpec::listdatums_size() const {
  return _internal_listdatums_size();
}
inline void PartitionBoundSpec::clear_listdatums() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.listdatums_.Clear();
}
inline ::pg_query::Node* PartitionBoundSpec::mutable_listdatums(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionBoundSpec.listdatums)
  return _internal_mutable_listdatums()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* PartitionBoundSpec::mutable_listdatums()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionBoundSpec.listdatums)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_listdatums();
}
inline const ::pg_query::Node& PartitionBoundSpec::listdatums(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.listdatums)
  return _internal_listdatums().Get(index);
}
inline ::pg_query::Node* PartitionBoundSpec::add_listdatums() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_listdatums()->Add();
  // @@protoc_insertion_point(field_add:pg_query.PartitionBoundSpec.listdatums)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& PartitionBoundSpec::listdatums() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.PartitionBoundSpec.listdatums)
  return _internal_listdatums();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
PartitionBoundSpec::_internal_listdatums() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.listdatums_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
PartitionBoundSpec::_internal_mutable_listdatums() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.listdatums_;
}

// repeated .pg_query.Node lowerdatums = 6 [json_name = "lowerdatums"];
inline int PartitionBoundSpec::_internal_lowerdatums_size() const {
  return _internal_lowerdatums().size();
}
inline int PartitionBoundSpec::lowerdatums_size() const {
  return _internal_lowerdatums_size();
}
inline void PartitionBoundSpec::clear_lowerdatums() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.lowerdatums_.Clear();
}
inline ::pg_query::Node* PartitionBoundSpec::mutable_lowerdatums(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionBoundSpec.lowerdatums)
  return _internal_mutable_lowerdatums()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* PartitionBoundSpec::mutable_lowerdatums()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionBoundSpec.lowerdatums)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_lowerdatums();
}
inline const ::pg_query::Node& PartitionBoundSpec::lowerdatums(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.lowerdatums)
  return _internal_lowerdatums().Get(index);
}
inline ::pg_query::Node* PartitionBoundSpec::add_lowerdatums() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_lowerdatums()->Add();
  // @@protoc_insertion_point(field_add:pg_query.PartitionBoundSpec.lowerdatums)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& PartitionBoundSpec::lowerdatums() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.PartitionBoundSpec.lowerdatums)
  return _internal_lowerdatums();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
PartitionBoundSpec::_internal_lowerdatums() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.lowerdatums_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
PartitionBoundSpec::_internal_mutable_lowerdatums() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.lowerdatums_;
}

// repeated .pg_query.Node upperdatums = 7 [json_name = "upperdatums"];
inline int PartitionBoundSpec::_internal_upperdatums_size() const {
  return _internal_upperdatums().size();
}
inline int PartitionBoundSpec::upperdatums_size() const {
  return _internal_upperdatums_size();
}
inline void PartitionBoundSpec::clear_upperdatums() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.upperdatums_.Clear();
}
inline ::pg_query::Node* PartitionBoundSpec::mutable_upperdatums(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionBoundSpec.upperdatums)
  return _internal_mutable_upperdatums()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* PartitionBoundSpec::mutable_upperdatums()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionBoundSpec.upperdatums)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_upperdatums();
}
inline const ::pg_query::Node& PartitionBoundSpec::upperdatums(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.upperdatums)
  return _internal_upperdatums().Get(index);
}
inline ::pg_query::Node* PartitionBoundSpec::add_upperdatums() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_upperdatums()->Add();
  // @@protoc_insertion_point(field_add:pg_query.PartitionBoundSpec.upperdatums)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& PartitionBoundSpec::upperdatums() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.PartitionBoundSpec.upperdatums)
  return _internal_upperdatums();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
PartitionBoundSpec::_internal_upperdatums() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.upperdatums_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
PartitionBoundSpec::_internal_mutable_upperdatums() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.upperdatums_;
}

// int32 location = 8 [json_name = "location"];
inline void PartitionBoundSpec::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t PartitionBoundSpec::location() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.location)
  return _internal_location();
}
inline void PartitionBoundSpec::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.location)
}
inline ::int32_t PartitionBoundSpec::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void PartitionBoundSpec::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// PartitionRangeDatum

// .pg_query.PartitionRangeDatumKind kind = 1 [json_name = "kind"];
inline void PartitionRangeDatum::clear_kind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.kind_ = 0;
}
inline ::pg_query::PartitionRangeDatumKind PartitionRangeDatum::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionRangeDatum.kind)
  return _internal_kind();
}
inline void PartitionRangeDatum::set_kind(::pg_query::PartitionRangeDatumKind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionRangeDatum.kind)
}
inline ::pg_query::PartitionRangeDatumKind PartitionRangeDatum::_internal_kind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::PartitionRangeDatumKind>(_impl_.kind_);
}
inline void PartitionRangeDatum::_internal_set_kind(::pg_query::PartitionRangeDatumKind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.kind_ = value;
}

// .pg_query.Node value = 2 [json_name = "value"];
inline bool PartitionRangeDatum::has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr);
  return value;
}
inline void PartitionRangeDatum::clear_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.value_ != nullptr) _impl_.value_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& PartitionRangeDatum::_internal_value() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.value_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& PartitionRangeDatum::value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PartitionRangeDatum.value)
  return _internal_value();
}
inline void PartitionRangeDatum::unsafe_arena_set_allocated_value(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.value_);
  }
  _impl_.value_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PartitionRangeDatum.value)
}
inline ::pg_query::Node* PartitionRangeDatum::release_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.value_;
  _impl_.value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* PartitionRangeDatum::unsafe_arena_release_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PartitionRangeDatum.value)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.value_;
  _impl_.value_ = nullptr;
  return temp;
}
inline ::pg_query::Node* PartitionRangeDatum::_internal_mutable_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.value_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.value_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.value_;
}
inline ::pg_query::Node* PartitionRangeDatum::mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionRangeDatum.value)
  return _msg;
}
inline void PartitionRangeDatum::set_allocated_value(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.value_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.value_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionRangeDatum.value)
}

// int32 location = 3 [json_name = "location"];
inline void PartitionRangeDatum::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t PartitionRangeDatum::location() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionRangeDatum.location)
  return _internal_location();
}
inline void PartitionRangeDatum::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionRangeDatum.location)
}
inline ::int32_t PartitionRangeDatum::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void PartitionRangeDatum::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// PartitionCmd

// .pg_query.RangeVar name = 1 [json_name = "name"];
inline bool PartitionCmd::has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.name_ != nullptr);
  return value;
}
inline void PartitionCmd::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.name_ != nullptr) _impl_.name_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& PartitionCmd::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.name_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& PartitionCmd::name() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PartitionCmd.name)
  return _internal_name();
}
inline void PartitionCmd::unsafe_arena_set_allocated_name(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.name_);
  }
  _impl_.name_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PartitionCmd.name)
}
inline ::pg_query::RangeVar* PartitionCmd::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.name_;
  _impl_.name_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* PartitionCmd::unsafe_arena_release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PartitionCmd.name)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.name_;
  _impl_.name_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* PartitionCmd::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.name_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.name_;
}
inline ::pg_query::RangeVar* PartitionCmd::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionCmd.name)
  return _msg;
}
inline void PartitionCmd::set_allocated_name(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.name_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.name_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionCmd.name)
}

// .pg_query.PartitionBoundSpec bound = 2 [json_name = "bound"];
inline bool PartitionCmd::has_bound() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bound_ != nullptr);
  return value;
}
inline void PartitionCmd::clear_bound() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.bound_ != nullptr) _impl_.bound_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::PartitionBoundSpec& PartitionCmd::_internal_bound() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::PartitionBoundSpec* p = _impl_.bound_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::PartitionBoundSpec&>(::pg_query::_PartitionBoundSpec_default_instance_);
}
inline const ::pg_query::PartitionBoundSpec& PartitionCmd::bound() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PartitionCmd.bound)
  return _internal_bound();
}
inline void PartitionCmd::unsafe_arena_set_allocated_bound(::pg_query::PartitionBoundSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.bound_);
  }
  _impl_.bound_ = reinterpret_cast<::pg_query::PartitionBoundSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PartitionCmd.bound)
}
inline ::pg_query::PartitionBoundSpec* PartitionCmd::release_bound() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::PartitionBoundSpec* released = _impl_.bound_;
  _impl_.bound_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::PartitionBoundSpec* PartitionCmd::unsafe_arena_release_bound() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PartitionCmd.bound)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::PartitionBoundSpec* temp = _impl_.bound_;
  _impl_.bound_ = nullptr;
  return temp;
}
inline ::pg_query::PartitionBoundSpec* PartitionCmd::_internal_mutable_bound() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.bound_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::PartitionBoundSpec>(GetArena());
    _impl_.bound_ = reinterpret_cast<::pg_query::PartitionBoundSpec*>(p);
  }
  return _impl_.bound_;
}
inline ::pg_query::PartitionBoundSpec* PartitionCmd::mutable_bound() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PartitionBoundSpec* _msg = _internal_mutable_bound();
  // @@protoc_insertion_point(field_mutable:pg_query.PartitionCmd.bound)
  return _msg;
}
inline void PartitionCmd::set_allocated_bound(::pg_query::PartitionBoundSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::PartitionBoundSpec*>(_impl_.bound_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::PartitionBoundSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.bound_ = reinterpret_cast<::pg_query::PartitionBoundSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionCmd.bound)
}

// bool concurrent = 3 [json_name = "concurrent"];
inline void PartitionCmd::clear_concurrent() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.concurrent_ = false;
}
inline bool PartitionCmd::concurrent() const {
  // @@protoc_insertion_point(field_get:pg_query.PartitionCmd.concurrent)
  return _internal_concurrent();
}
inline void PartitionCmd::set_concurrent(bool value) {
  _internal_set_concurrent(value);
  // @@protoc_insertion_point(field_set:pg_query.PartitionCmd.concurrent)
}
inline bool PartitionCmd::_internal_concurrent() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.concurrent_;
}
inline void PartitionCmd::_internal_set_concurrent(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.concurrent_ = value;
}

// -------------------------------------------------------------------

// RangeTblEntry

// .pg_query.RTEKind rtekind = 1 [json_name = "rtekind"];
inline void RangeTblEntry::clear_rtekind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rtekind_ = 0;
}
inline ::pg_query::RTEKind RangeTblEntry::rtekind() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.rtekind)
  return _internal_rtekind();
}
inline void RangeTblEntry::set_rtekind(::pg_query::RTEKind value) {
  _internal_set_rtekind(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.rtekind)
}
inline ::pg_query::RTEKind RangeTblEntry::_internal_rtekind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::RTEKind>(_impl_.rtekind_);
}
inline void RangeTblEntry::_internal_set_rtekind(::pg_query::RTEKind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.rtekind_ = value;
}

// uint32 relid = 2 [json_name = "relid"];
inline void RangeTblEntry::clear_relid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relid_ = 0u;
}
inline ::uint32_t RangeTblEntry::relid() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.relid)
  return _internal_relid();
}
inline void RangeTblEntry::set_relid(::uint32_t value) {
  _internal_set_relid(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.relid)
}
inline ::uint32_t RangeTblEntry::_internal_relid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.relid_;
}
inline void RangeTblEntry::_internal_set_relid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relid_ = value;
}

// string relkind = 3 [json_name = "relkind"];
inline void RangeTblEntry::clear_relkind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relkind_.ClearToEmpty();
}
inline const std::string& RangeTblEntry::relkind() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.relkind)
  return _internal_relkind();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RangeTblEntry::set_relkind(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relkind_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.relkind)
}
inline std::string* RangeTblEntry::mutable_relkind() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_relkind();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.relkind)
  return _s;
}
inline const std::string& RangeTblEntry::_internal_relkind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.relkind_.Get();
}
inline void RangeTblEntry::_internal_set_relkind(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relkind_.Set(value, GetArena());
}
inline std::string* RangeTblEntry::_internal_mutable_relkind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.relkind_.Mutable( GetArena());
}
inline std::string* RangeTblEntry::release_relkind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.relkind)
  return _impl_.relkind_.Release();
}
inline void RangeTblEntry::set_allocated_relkind(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relkind_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.relkind_.IsDefault()) {
          _impl_.relkind_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.relkind)
}

// int32 rellockmode = 4 [json_name = "rellockmode"];
inline void RangeTblEntry::clear_rellockmode() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rellockmode_ = 0;
}
inline ::int32_t RangeTblEntry::rellockmode() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.rellockmode)
  return _internal_rellockmode();
}
inline void RangeTblEntry::set_rellockmode(::int32_t value) {
  _internal_set_rellockmode(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.rellockmode)
}
inline ::int32_t RangeTblEntry::_internal_rellockmode() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.rellockmode_;
}
inline void RangeTblEntry::_internal_set_rellockmode(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.rellockmode_ = value;
}

// .pg_query.TableSampleClause tablesample = 5 [json_name = "tablesample"];
inline bool RangeTblEntry::has_tablesample() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.tablesample_ != nullptr);
  return value;
}
inline void RangeTblEntry::clear_tablesample() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.tablesample_ != nullptr) _impl_.tablesample_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::TableSampleClause& RangeTblEntry::_internal_tablesample() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TableSampleClause* p = _impl_.tablesample_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TableSampleClause&>(::pg_query::_TableSampleClause_default_instance_);
}
inline const ::pg_query::TableSampleClause& RangeTblEntry::tablesample() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.tablesample)
  return _internal_tablesample();
}
inline void RangeTblEntry::unsafe_arena_set_allocated_tablesample(::pg_query::TableSampleClause* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tablesample_);
  }
  _impl_.tablesample_ = reinterpret_cast<::pg_query::TableSampleClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.tablesample)
}
inline ::pg_query::TableSampleClause* RangeTblEntry::release_tablesample() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TableSampleClause* released = _impl_.tablesample_;
  _impl_.tablesample_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TableSampleClause* RangeTblEntry::unsafe_arena_release_tablesample() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.tablesample)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TableSampleClause* temp = _impl_.tablesample_;
  _impl_.tablesample_ = nullptr;
  return temp;
}
inline ::pg_query::TableSampleClause* RangeTblEntry::_internal_mutable_tablesample() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.tablesample_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TableSampleClause>(GetArena());
    _impl_.tablesample_ = reinterpret_cast<::pg_query::TableSampleClause*>(p);
  }
  return _impl_.tablesample_;
}
inline ::pg_query::TableSampleClause* RangeTblEntry::mutable_tablesample() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TableSampleClause* _msg = _internal_mutable_tablesample();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.tablesample)
  return _msg;
}
inline void RangeTblEntry::set_allocated_tablesample(::pg_query::TableSampleClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TableSampleClause*>(_impl_.tablesample_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TableSampleClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.tablesample_ = reinterpret_cast<::pg_query::TableSampleClause*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.tablesample)
}

// uint32 perminfoindex = 6 [json_name = "perminfoindex"];
inline void RangeTblEntry::clear_perminfoindex() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.perminfoindex_ = 0u;
}
inline ::uint32_t RangeTblEntry::perminfoindex() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.perminfoindex)
  return _internal_perminfoindex();
}
inline void RangeTblEntry::set_perminfoindex(::uint32_t value) {
  _internal_set_perminfoindex(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.perminfoindex)
}
inline ::uint32_t RangeTblEntry::_internal_perminfoindex() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.perminfoindex_;
}
inline void RangeTblEntry::_internal_set_perminfoindex(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.perminfoindex_ = value;
}

// .pg_query.Query subquery = 7 [json_name = "subquery"];
inline bool RangeTblEntry::has_subquery() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.subquery_ != nullptr);
  return value;
}
inline void RangeTblEntry::clear_subquery() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.subquery_ != nullptr) _impl_.subquery_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Query& RangeTblEntry::_internal_subquery() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Query* p = _impl_.subquery_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Query&>(::pg_query::_Query_default_instance_);
}
inline const ::pg_query::Query& RangeTblEntry::subquery() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.subquery)
  return _internal_subquery();
}
inline void RangeTblEntry::unsafe_arena_set_allocated_subquery(::pg_query::Query* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.subquery_);
  }
  _impl_.subquery_ = reinterpret_cast<::pg_query::Query*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.subquery)
}
inline ::pg_query::Query* RangeTblEntry::release_subquery() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Query* released = _impl_.subquery_;
  _impl_.subquery_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Query* RangeTblEntry::unsafe_arena_release_subquery() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.subquery)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Query* temp = _impl_.subquery_;
  _impl_.subquery_ = nullptr;
  return temp;
}
inline ::pg_query::Query* RangeTblEntry::_internal_mutable_subquery() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.subquery_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Query>(GetArena());
    _impl_.subquery_ = reinterpret_cast<::pg_query::Query*>(p);
  }
  return _impl_.subquery_;
}
inline ::pg_query::Query* RangeTblEntry::mutable_subquery() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Query* _msg = _internal_mutable_subquery();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.subquery)
  return _msg;
}
inline void RangeTblEntry::set_allocated_subquery(::pg_query::Query* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Query*>(_impl_.subquery_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Query*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.subquery_ = reinterpret_cast<::pg_query::Query*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.subquery)
}

// bool security_barrier = 8 [json_name = "security_barrier"];
inline void RangeTblEntry::clear_security_barrier() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.security_barrier_ = false;
}
inline bool RangeTblEntry::security_barrier() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.security_barrier)
  return _internal_security_barrier();
}
inline void RangeTblEntry::set_security_barrier(bool value) {
  _internal_set_security_barrier(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.security_barrier)
}
inline bool RangeTblEntry::_internal_security_barrier() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.security_barrier_;
}
inline void RangeTblEntry::_internal_set_security_barrier(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.security_barrier_ = value;
}

// .pg_query.JoinType jointype = 9 [json_name = "jointype"];
inline void RangeTblEntry::clear_jointype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.jointype_ = 0;
}
inline ::pg_query::JoinType RangeTblEntry::jointype() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.jointype)
  return _internal_jointype();
}
inline void RangeTblEntry::set_jointype(::pg_query::JoinType value) {
  _internal_set_jointype(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.jointype)
}
inline ::pg_query::JoinType RangeTblEntry::_internal_jointype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::JoinType>(_impl_.jointype_);
}
inline void RangeTblEntry::_internal_set_jointype(::pg_query::JoinType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.jointype_ = value;
}

// int32 joinmergedcols = 10 [json_name = "joinmergedcols"];
inline void RangeTblEntry::clear_joinmergedcols() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.joinmergedcols_ = 0;
}
inline ::int32_t RangeTblEntry::joinmergedcols() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.joinmergedcols)
  return _internal_joinmergedcols();
}
inline void RangeTblEntry::set_joinmergedcols(::int32_t value) {
  _internal_set_joinmergedcols(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.joinmergedcols)
}
inline ::int32_t RangeTblEntry::_internal_joinmergedcols() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.joinmergedcols_;
}
inline void RangeTblEntry::_internal_set_joinmergedcols(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.joinmergedcols_ = value;
}

// repeated .pg_query.Node joinaliasvars = 11 [json_name = "joinaliasvars"];
inline int RangeTblEntry::_internal_joinaliasvars_size() const {
  return _internal_joinaliasvars().size();
}
inline int RangeTblEntry::joinaliasvars_size() const {
  return _internal_joinaliasvars_size();
}
inline void RangeTblEntry::clear_joinaliasvars() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.joinaliasvars_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_joinaliasvars(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.joinaliasvars)
  return _internal_mutable_joinaliasvars()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblEntry::mutable_joinaliasvars()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.joinaliasvars)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_joinaliasvars();
}
inline const ::pg_query::Node& RangeTblEntry::joinaliasvars(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.joinaliasvars)
  return _internal_joinaliasvars().Get(index);
}
inline ::pg_query::Node* RangeTblEntry::add_joinaliasvars() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_joinaliasvars()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.joinaliasvars)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblEntry::joinaliasvars() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.joinaliasvars)
  return _internal_joinaliasvars();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblEntry::_internal_joinaliasvars() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.joinaliasvars_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblEntry::_internal_mutable_joinaliasvars() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.joinaliasvars_;
}

// repeated .pg_query.Node joinleftcols = 12 [json_name = "joinleftcols"];
inline int RangeTblEntry::_internal_joinleftcols_size() const {
  return _internal_joinleftcols().size();
}
inline int RangeTblEntry::joinleftcols_size() const {
  return _internal_joinleftcols_size();
}
inline void RangeTblEntry::clear_joinleftcols() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.joinleftcols_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_joinleftcols(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.joinleftcols)
  return _internal_mutable_joinleftcols()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblEntry::mutable_joinleftcols()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.joinleftcols)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_joinleftcols();
}
inline const ::pg_query::Node& RangeTblEntry::joinleftcols(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.joinleftcols)
  return _internal_joinleftcols().Get(index);
}
inline ::pg_query::Node* RangeTblEntry::add_joinleftcols() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_joinleftcols()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.joinleftcols)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblEntry::joinleftcols() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.joinleftcols)
  return _internal_joinleftcols();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblEntry::_internal_joinleftcols() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.joinleftcols_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblEntry::_internal_mutable_joinleftcols() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.joinleftcols_;
}

// repeated .pg_query.Node joinrightcols = 13 [json_name = "joinrightcols"];
inline int RangeTblEntry::_internal_joinrightcols_size() const {
  return _internal_joinrightcols().size();
}
inline int RangeTblEntry::joinrightcols_size() const {
  return _internal_joinrightcols_size();
}
inline void RangeTblEntry::clear_joinrightcols() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.joinrightcols_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_joinrightcols(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.joinrightcols)
  return _internal_mutable_joinrightcols()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblEntry::mutable_joinrightcols()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.joinrightcols)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_joinrightcols();
}
inline const ::pg_query::Node& RangeTblEntry::joinrightcols(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.joinrightcols)
  return _internal_joinrightcols().Get(index);
}
inline ::pg_query::Node* RangeTblEntry::add_joinrightcols() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_joinrightcols()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.joinrightcols)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblEntry::joinrightcols() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.joinrightcols)
  return _internal_joinrightcols();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblEntry::_internal_joinrightcols() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.joinrightcols_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblEntry::_internal_mutable_joinrightcols() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.joinrightcols_;
}

// .pg_query.Alias join_using_alias = 14 [json_name = "join_using_alias"];
inline bool RangeTblEntry::has_join_using_alias() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.join_using_alias_ != nullptr);
  return value;
}
inline void RangeTblEntry::clear_join_using_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.join_using_alias_ != nullptr) _impl_.join_using_alias_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Alias& RangeTblEntry::_internal_join_using_alias() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Alias* p = _impl_.join_using_alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeTblEntry::join_using_alias() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.join_using_alias)
  return _internal_join_using_alias();
}
inline void RangeTblEntry::unsafe_arena_set_allocated_join_using_alias(::pg_query::Alias* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.join_using_alias_);
  }
  _impl_.join_using_alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.join_using_alias)
}
inline ::pg_query::Alias* RangeTblEntry::release_join_using_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Alias* released = _impl_.join_using_alias_;
  _impl_.join_using_alias_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Alias* RangeTblEntry::unsafe_arena_release_join_using_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.join_using_alias)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Alias* temp = _impl_.join_using_alias_;
  _impl_.join_using_alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeTblEntry::_internal_mutable_join_using_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.join_using_alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    _impl_.join_using_alias_ = reinterpret_cast<::pg_query::Alias*>(p);
  }
  return _impl_.join_using_alias_;
}
inline ::pg_query::Alias* RangeTblEntry::mutable_join_using_alias() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Alias* _msg = _internal_mutable_join_using_alias();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.join_using_alias)
  return _msg;
}
inline void RangeTblEntry::set_allocated_join_using_alias(::pg_query::Alias* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Alias*>(_impl_.join_using_alias_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Alias*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.join_using_alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.join_using_alias)
}

// repeated .pg_query.Node functions = 15 [json_name = "functions"];
inline int RangeTblEntry::_internal_functions_size() const {
  return _internal_functions().size();
}
inline int RangeTblEntry::functions_size() const {
  return _internal_functions_size();
}
inline void RangeTblEntry::clear_functions() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.functions_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_functions(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.functions)
  return _internal_mutable_functions()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblEntry::mutable_functions()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.functions)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_functions();
}
inline const ::pg_query::Node& RangeTblEntry::functions(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.functions)
  return _internal_functions().Get(index);
}
inline ::pg_query::Node* RangeTblEntry::add_functions() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_functions()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.functions)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblEntry::functions() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.functions)
  return _internal_functions();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblEntry::_internal_functions() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.functions_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblEntry::_internal_mutable_functions() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.functions_;
}

// bool funcordinality = 16 [json_name = "funcordinality"];
inline void RangeTblEntry::clear_funcordinality() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funcordinality_ = false;
}
inline bool RangeTblEntry::funcordinality() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.funcordinality)
  return _internal_funcordinality();
}
inline void RangeTblEntry::set_funcordinality(bool value) {
  _internal_set_funcordinality(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.funcordinality)
}
inline bool RangeTblEntry::_internal_funcordinality() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funcordinality_;
}
inline void RangeTblEntry::_internal_set_funcordinality(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.funcordinality_ = value;
}

// .pg_query.TableFunc tablefunc = 17 [json_name = "tablefunc"];
inline bool RangeTblEntry::has_tablefunc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.tablefunc_ != nullptr);
  return value;
}
inline void RangeTblEntry::clear_tablefunc() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.tablefunc_ != nullptr) _impl_.tablefunc_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::pg_query::TableFunc& RangeTblEntry::_internal_tablefunc() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TableFunc* p = _impl_.tablefunc_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TableFunc&>(::pg_query::_TableFunc_default_instance_);
}
inline const ::pg_query::TableFunc& RangeTblEntry::tablefunc() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.tablefunc)
  return _internal_tablefunc();
}
inline void RangeTblEntry::unsafe_arena_set_allocated_tablefunc(::pg_query::TableFunc* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tablefunc_);
  }
  _impl_.tablefunc_ = reinterpret_cast<::pg_query::TableFunc*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.tablefunc)
}
inline ::pg_query::TableFunc* RangeTblEntry::release_tablefunc() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::TableFunc* released = _impl_.tablefunc_;
  _impl_.tablefunc_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TableFunc* RangeTblEntry::unsafe_arena_release_tablefunc() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.tablefunc)

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::TableFunc* temp = _impl_.tablefunc_;
  _impl_.tablefunc_ = nullptr;
  return temp;
}
inline ::pg_query::TableFunc* RangeTblEntry::_internal_mutable_tablefunc() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.tablefunc_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TableFunc>(GetArena());
    _impl_.tablefunc_ = reinterpret_cast<::pg_query::TableFunc*>(p);
  }
  return _impl_.tablefunc_;
}
inline ::pg_query::TableFunc* RangeTblEntry::mutable_tablefunc() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TableFunc* _msg = _internal_mutable_tablefunc();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.tablefunc)
  return _msg;
}
inline void RangeTblEntry::set_allocated_tablefunc(::pg_query::TableFunc* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TableFunc*>(_impl_.tablefunc_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TableFunc*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }

  _impl_.tablefunc_ = reinterpret_cast<::pg_query::TableFunc*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.tablefunc)
}

// repeated .pg_query.Node values_lists = 18 [json_name = "values_lists"];
inline int RangeTblEntry::_internal_values_lists_size() const {
  return _internal_values_lists().size();
}
inline int RangeTblEntry::values_lists_size() const {
  return _internal_values_lists_size();
}
inline void RangeTblEntry::clear_values_lists() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.values_lists_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_values_lists(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.values_lists)
  return _internal_mutable_values_lists()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblEntry::mutable_values_lists()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.values_lists)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_values_lists();
}
inline const ::pg_query::Node& RangeTblEntry::values_lists(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.values_lists)
  return _internal_values_lists().Get(index);
}
inline ::pg_query::Node* RangeTblEntry::add_values_lists() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_values_lists()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.values_lists)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblEntry::values_lists() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.values_lists)
  return _internal_values_lists();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblEntry::_internal_values_lists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.values_lists_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblEntry::_internal_mutable_values_lists() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.values_lists_;
}

// string ctename = 19 [json_name = "ctename"];
inline void RangeTblEntry::clear_ctename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ctename_.ClearToEmpty();
}
inline const std::string& RangeTblEntry::ctename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.ctename)
  return _internal_ctename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RangeTblEntry::set_ctename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ctename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.ctename)
}
inline std::string* RangeTblEntry::mutable_ctename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_ctename();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.ctename)
  return _s;
}
inline const std::string& RangeTblEntry::_internal_ctename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ctename_.Get();
}
inline void RangeTblEntry::_internal_set_ctename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ctename_.Set(value, GetArena());
}
inline std::string* RangeTblEntry::_internal_mutable_ctename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.ctename_.Mutable( GetArena());
}
inline std::string* RangeTblEntry::release_ctename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.ctename)
  return _impl_.ctename_.Release();
}
inline void RangeTblEntry::set_allocated_ctename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ctename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.ctename_.IsDefault()) {
          _impl_.ctename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.ctename)
}

// uint32 ctelevelsup = 20 [json_name = "ctelevelsup"];
inline void RangeTblEntry::clear_ctelevelsup() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ctelevelsup_ = 0u;
}
inline ::uint32_t RangeTblEntry::ctelevelsup() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.ctelevelsup)
  return _internal_ctelevelsup();
}
inline void RangeTblEntry::set_ctelevelsup(::uint32_t value) {
  _internal_set_ctelevelsup(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.ctelevelsup)
}
inline ::uint32_t RangeTblEntry::_internal_ctelevelsup() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ctelevelsup_;
}
inline void RangeTblEntry::_internal_set_ctelevelsup(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ctelevelsup_ = value;
}

// bool self_reference = 21 [json_name = "self_reference"];
inline void RangeTblEntry::clear_self_reference() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.self_reference_ = false;
}
inline bool RangeTblEntry::self_reference() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.self_reference)
  return _internal_self_reference();
}
inline void RangeTblEntry::set_self_reference(bool value) {
  _internal_set_self_reference(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.self_reference)
}
inline bool RangeTblEntry::_internal_self_reference() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.self_reference_;
}
inline void RangeTblEntry::_internal_set_self_reference(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.self_reference_ = value;
}

// repeated .pg_query.Node coltypes = 22 [json_name = "coltypes"];
inline int RangeTblEntry::_internal_coltypes_size() const {
  return _internal_coltypes().size();
}
inline int RangeTblEntry::coltypes_size() const {
  return _internal_coltypes_size();
}
inline void RangeTblEntry::clear_coltypes() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coltypes_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_coltypes(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.coltypes)
  return _internal_mutable_coltypes()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblEntry::mutable_coltypes()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.coltypes)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_coltypes();
}
inline const ::pg_query::Node& RangeTblEntry::coltypes(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.coltypes)
  return _internal_coltypes().Get(index);
}
inline ::pg_query::Node* RangeTblEntry::add_coltypes() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_coltypes()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.coltypes)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblEntry::coltypes() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.coltypes)
  return _internal_coltypes();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblEntry::_internal_coltypes() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.coltypes_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblEntry::_internal_mutable_coltypes() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.coltypes_;
}

// repeated .pg_query.Node coltypmods = 23 [json_name = "coltypmods"];
inline int RangeTblEntry::_internal_coltypmods_size() const {
  return _internal_coltypmods().size();
}
inline int RangeTblEntry::coltypmods_size() const {
  return _internal_coltypmods_size();
}
inline void RangeTblEntry::clear_coltypmods() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coltypmods_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_coltypmods(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.coltypmods)
  return _internal_mutable_coltypmods()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblEntry::mutable_coltypmods()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.coltypmods)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_coltypmods();
}
inline const ::pg_query::Node& RangeTblEntry::coltypmods(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.coltypmods)
  return _internal_coltypmods().Get(index);
}
inline ::pg_query::Node* RangeTblEntry::add_coltypmods() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_coltypmods()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.coltypmods)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblEntry::coltypmods() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.coltypmods)
  return _internal_coltypmods();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblEntry::_internal_coltypmods() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.coltypmods_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblEntry::_internal_mutable_coltypmods() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.coltypmods_;
}

// repeated .pg_query.Node colcollations = 24 [json_name = "colcollations"];
inline int RangeTblEntry::_internal_colcollations_size() const {
  return _internal_colcollations().size();
}
inline int RangeTblEntry::colcollations_size() const {
  return _internal_colcollations_size();
}
inline void RangeTblEntry::clear_colcollations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.colcollations_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_colcollations(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.colcollations)
  return _internal_mutable_colcollations()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblEntry::mutable_colcollations()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.colcollations)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_colcollations();
}
inline const ::pg_query::Node& RangeTblEntry::colcollations(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.colcollations)
  return _internal_colcollations().Get(index);
}
inline ::pg_query::Node* RangeTblEntry::add_colcollations() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_colcollations()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.colcollations)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblEntry::colcollations() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.colcollations)
  return _internal_colcollations();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblEntry::_internal_colcollations() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.colcollations_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblEntry::_internal_mutable_colcollations() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.colcollations_;
}

// string enrname = 25 [json_name = "enrname"];
inline void RangeTblEntry::clear_enrname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.enrname_.ClearToEmpty();
}
inline const std::string& RangeTblEntry::enrname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.enrname)
  return _internal_enrname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RangeTblEntry::set_enrname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.enrname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.enrname)
}
inline std::string* RangeTblEntry::mutable_enrname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_enrname();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.enrname)
  return _s;
}
inline const std::string& RangeTblEntry::_internal_enrname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.enrname_.Get();
}
inline void RangeTblEntry::_internal_set_enrname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.enrname_.Set(value, GetArena());
}
inline std::string* RangeTblEntry::_internal_mutable_enrname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.enrname_.Mutable( GetArena());
}
inline std::string* RangeTblEntry::release_enrname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.enrname)
  return _impl_.enrname_.Release();
}
inline void RangeTblEntry::set_allocated_enrname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.enrname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.enrname_.IsDefault()) {
          _impl_.enrname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.enrname)
}

// double enrtuples = 26 [json_name = "enrtuples"];
inline void RangeTblEntry::clear_enrtuples() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.enrtuples_ = 0;
}
inline double RangeTblEntry::enrtuples() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.enrtuples)
  return _internal_enrtuples();
}
inline void RangeTblEntry::set_enrtuples(double value) {
  _internal_set_enrtuples(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.enrtuples)
}
inline double RangeTblEntry::_internal_enrtuples() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.enrtuples_;
}
inline void RangeTblEntry::_internal_set_enrtuples(double value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.enrtuples_ = value;
}

// .pg_query.Alias alias = 27 [json_name = "alias"];
inline bool RangeTblEntry::has_alias() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.alias_ != nullptr);
  return value;
}
inline void RangeTblEntry::clear_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.alias_ != nullptr) _impl_.alias_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::pg_query::Alias& RangeTblEntry::_internal_alias() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Alias* p = _impl_.alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeTblEntry::alias() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.alias)
  return _internal_alias();
}
inline void RangeTblEntry::unsafe_arena_set_allocated_alias(::pg_query::Alias* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.alias_);
  }
  _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.alias)
}
inline ::pg_query::Alias* RangeTblEntry::release_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000010u;
  ::pg_query::Alias* released = _impl_.alias_;
  _impl_.alias_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Alias* RangeTblEntry::unsafe_arena_release_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.alias)

  _impl_._has_bits_[0] &= ~0x00000010u;
  ::pg_query::Alias* temp = _impl_.alias_;
  _impl_.alias_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeTblEntry::_internal_mutable_alias() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(p);
  }
  return _impl_.alias_;
}
inline ::pg_query::Alias* RangeTblEntry::mutable_alias() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Alias* _msg = _internal_mutable_alias();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.alias)
  return _msg;
}
inline void RangeTblEntry::set_allocated_alias(::pg_query::Alias* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Alias*>(_impl_.alias_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Alias*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }

  _impl_.alias_ = reinterpret_cast<::pg_query::Alias*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.alias)
}

// .pg_query.Alias eref = 28 [json_name = "eref"];
inline bool RangeTblEntry::has_eref() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.eref_ != nullptr);
  return value;
}
inline void RangeTblEntry::clear_eref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.eref_ != nullptr) _impl_.eref_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::pg_query::Alias& RangeTblEntry::_internal_eref() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Alias* p = _impl_.eref_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Alias&>(::pg_query::_Alias_default_instance_);
}
inline const ::pg_query::Alias& RangeTblEntry::eref() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.eref)
  return _internal_eref();
}
inline void RangeTblEntry::unsafe_arena_set_allocated_eref(::pg_query::Alias* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.eref_);
  }
  _impl_.eref_ = reinterpret_cast<::pg_query::Alias*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.eref)
}
inline ::pg_query::Alias* RangeTblEntry::release_eref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000020u;
  ::pg_query::Alias* released = _impl_.eref_;
  _impl_.eref_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Alias* RangeTblEntry::unsafe_arena_release_eref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.eref)

  _impl_._has_bits_[0] &= ~0x00000020u;
  ::pg_query::Alias* temp = _impl_.eref_;
  _impl_.eref_ = nullptr;
  return temp;
}
inline ::pg_query::Alias* RangeTblEntry::_internal_mutable_eref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.eref_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArena());
    _impl_.eref_ = reinterpret_cast<::pg_query::Alias*>(p);
  }
  return _impl_.eref_;
}
inline ::pg_query::Alias* RangeTblEntry::mutable_eref() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Alias* _msg = _internal_mutable_eref();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.eref)
  return _msg;
}
inline void RangeTblEntry::set_allocated_eref(::pg_query::Alias* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Alias*>(_impl_.eref_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Alias*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }

  _impl_.eref_ = reinterpret_cast<::pg_query::Alias*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.eref)
}

// bool lateral = 29 [json_name = "lateral"];
inline void RangeTblEntry::clear_lateral() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.lateral_ = false;
}
inline bool RangeTblEntry::lateral() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.lateral)
  return _internal_lateral();
}
inline void RangeTblEntry::set_lateral(bool value) {
  _internal_set_lateral(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.lateral)
}
inline bool RangeTblEntry::_internal_lateral() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.lateral_;
}
inline void RangeTblEntry::_internal_set_lateral(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.lateral_ = value;
}

// bool inh = 30 [json_name = "inh"];
inline void RangeTblEntry::clear_inh() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inh_ = false;
}
inline bool RangeTblEntry::inh() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.inh)
  return _internal_inh();
}
inline void RangeTblEntry::set_inh(bool value) {
  _internal_set_inh(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.inh)
}
inline bool RangeTblEntry::_internal_inh() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inh_;
}
inline void RangeTblEntry::_internal_set_inh(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inh_ = value;
}

// bool in_from_cl = 31 [json_name = "inFromCl"];
inline void RangeTblEntry::clear_in_from_cl() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.in_from_cl_ = false;
}
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::set_in_from_cl(bool value) {
  _internal_set_in_from_cl(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.in_from_cl)
}
inline bool RangeTblEntry::_internal_in_from_cl() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.in_from_cl_;
}
inline void RangeTblEntry::_internal_set_in_from_cl(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.in_from_cl_ = value;
}

// repeated .pg_query.Node security_quals = 32 [json_name = "securityQuals"];
inline int RangeTblEntry::_internal_security_quals_size() const {
  return _internal_security_quals().size();
}
inline int RangeTblEntry::security_quals_size() const {
  return _internal_security_quals_size();
}
inline void RangeTblEntry::clear_security_quals() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.security_quals_.Clear();
}
inline ::pg_query::Node* RangeTblEntry::mutable_security_quals(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.security_quals)
  return _internal_mutable_security_quals()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblEntry::mutable_security_quals()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.security_quals)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_security_quals();
}
inline const ::pg_query::Node& RangeTblEntry::security_quals(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.security_quals)
  return _internal_security_quals().Get(index);
}
inline ::pg_query::Node* RangeTblEntry::add_security_quals() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_security_quals()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.security_quals)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblEntry::security_quals() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.security_quals)
  return _internal_security_quals();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblEntry::_internal_security_quals() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.security_quals_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblEntry::_internal_mutable_security_quals() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.security_quals_;
}

// -------------------------------------------------------------------

// RTEPermissionInfo

// uint32 relid = 1 [json_name = "relid"];
inline void RTEPermissionInfo::clear_relid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relid_ = 0u;
}
inline ::uint32_t RTEPermissionInfo::relid() const {
  // @@protoc_insertion_point(field_get:pg_query.RTEPermissionInfo.relid)
  return _internal_relid();
}
inline void RTEPermissionInfo::set_relid(::uint32_t value) {
  _internal_set_relid(value);
  // @@protoc_insertion_point(field_set:pg_query.RTEPermissionInfo.relid)
}
inline ::uint32_t RTEPermissionInfo::_internal_relid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.relid_;
}
inline void RTEPermissionInfo::_internal_set_relid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relid_ = value;
}

// bool inh = 2 [json_name = "inh"];
inline void RTEPermissionInfo::clear_inh() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inh_ = false;
}
inline bool RTEPermissionInfo::inh() const {
  // @@protoc_insertion_point(field_get:pg_query.RTEPermissionInfo.inh)
  return _internal_inh();
}
inline void RTEPermissionInfo::set_inh(bool value) {
  _internal_set_inh(value);
  // @@protoc_insertion_point(field_set:pg_query.RTEPermissionInfo.inh)
}
inline bool RTEPermissionInfo::_internal_inh() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inh_;
}
inline void RTEPermissionInfo::_internal_set_inh(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inh_ = value;
}

// int64 required_perms = 3 [json_name = "requiredPerms"];
inline void RTEPermissionInfo::clear_required_perms() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.required_perms_ = ::int64_t{0};
}
inline ::int64_t RTEPermissionInfo::required_perms() const {
  // @@protoc_insertion_point(field_get:pg_query.RTEPermissionInfo.required_perms)
  return _internal_required_perms();
}
inline void RTEPermissionInfo::set_required_perms(::int64_t value) {
  _internal_set_required_perms(value);
  // @@protoc_insertion_point(field_set:pg_query.RTEPermissionInfo.required_perms)
}
inline ::int64_t RTEPermissionInfo::_internal_required_perms() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.required_perms_;
}
inline void RTEPermissionInfo::_internal_set_required_perms(::int64_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.required_perms_ = value;
}

// uint32 check_as_user = 4 [json_name = "checkAsUser"];
inline void RTEPermissionInfo::clear_check_as_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.check_as_user_ = 0u;
}
inline ::uint32_t RTEPermissionInfo::check_as_user() const {
  // @@protoc_insertion_point(field_get:pg_query.RTEPermissionInfo.check_as_user)
  return _internal_check_as_user();
}
inline void RTEPermissionInfo::set_check_as_user(::uint32_t value) {
  _internal_set_check_as_user(value);
  // @@protoc_insertion_point(field_set:pg_query.RTEPermissionInfo.check_as_user)
}
inline ::uint32_t RTEPermissionInfo::_internal_check_as_user() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.check_as_user_;
}
inline void RTEPermissionInfo::_internal_set_check_as_user(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.check_as_user_ = value;
}

// repeated uint64 selected_cols = 5 [json_name = "selectedCols"];
inline int RTEPermissionInfo::_internal_selected_cols_size() const {
  return _internal_selected_cols().size();
}
inline int RTEPermissionInfo::selected_cols_size() const {
  return _internal_selected_cols_size();
}
inline void RTEPermissionInfo::clear_selected_cols() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.selected_cols_.Clear();
}
inline ::uint64_t RTEPermissionInfo::selected_cols(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RTEPermissionInfo.selected_cols)
  return _internal_selected_cols().Get(index);
}
inline void RTEPermissionInfo::set_selected_cols(int index, ::uint64_t value) {
  _internal_mutable_selected_cols()->Set(index, value);
  // @@protoc_insertion_point(field_set:pg_query.RTEPermissionInfo.selected_cols)
}
inline void RTEPermissionInfo::add_selected_cols(::uint64_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_selected_cols()->Add(value);
  // @@protoc_insertion_point(field_add:pg_query.RTEPermissionInfo.selected_cols)
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& RTEPermissionInfo::selected_cols() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RTEPermissionInfo.selected_cols)
  return _internal_selected_cols();
}
inline ::google::protobuf::RepeatedField<::uint64_t>* RTEPermissionInfo::mutable_selected_cols()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RTEPermissionInfo.selected_cols)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_selected_cols();
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& RTEPermissionInfo::_internal_selected_cols()
    const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.selected_cols_;
}
inline ::google::protobuf::RepeatedField<::uint64_t>* RTEPermissionInfo::_internal_mutable_selected_cols() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.selected_cols_;
}

// repeated uint64 inserted_cols = 6 [json_name = "insertedCols"];
inline int RTEPermissionInfo::_internal_inserted_cols_size() const {
  return _internal_inserted_cols().size();
}
inline int RTEPermissionInfo::inserted_cols_size() const {
  return _internal_inserted_cols_size();
}
inline void RTEPermissionInfo::clear_inserted_cols() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inserted_cols_.Clear();
}
inline ::uint64_t RTEPermissionInfo::inserted_cols(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RTEPermissionInfo.inserted_cols)
  return _internal_inserted_cols().Get(index);
}
inline void RTEPermissionInfo::set_inserted_cols(int index, ::uint64_t value) {
  _internal_mutable_inserted_cols()->Set(index, value);
  // @@protoc_insertion_point(field_set:pg_query.RTEPermissionInfo.inserted_cols)
}
inline void RTEPermissionInfo::add_inserted_cols(::uint64_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_inserted_cols()->Add(value);
  // @@protoc_insertion_point(field_add:pg_query.RTEPermissionInfo.inserted_cols)
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& RTEPermissionInfo::inserted_cols() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RTEPermissionInfo.inserted_cols)
  return _internal_inserted_cols();
}
inline ::google::protobuf::RepeatedField<::uint64_t>* RTEPermissionInfo::mutable_inserted_cols()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RTEPermissionInfo.inserted_cols)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_inserted_cols();
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& RTEPermissionInfo::_internal_inserted_cols()
    const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inserted_cols_;
}
inline ::google::protobuf::RepeatedField<::uint64_t>* RTEPermissionInfo::_internal_mutable_inserted_cols() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.inserted_cols_;
}

// repeated uint64 updated_cols = 7 [json_name = "updatedCols"];
inline int RTEPermissionInfo::_internal_updated_cols_size() const {
  return _internal_updated_cols().size();
}
inline int RTEPermissionInfo::updated_cols_size() const {
  return _internal_updated_cols_size();
}
inline void RTEPermissionInfo::clear_updated_cols() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.updated_cols_.Clear();
}
inline ::uint64_t RTEPermissionInfo::updated_cols(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RTEPermissionInfo.updated_cols)
  return _internal_updated_cols().Get(index);
}
inline void RTEPermissionInfo::set_updated_cols(int index, ::uint64_t value) {
  _internal_mutable_updated_cols()->Set(index, value);
  // @@protoc_insertion_point(field_set:pg_query.RTEPermissionInfo.updated_cols)
}
inline void RTEPermissionInfo::add_updated_cols(::uint64_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_updated_cols()->Add(value);
  // @@protoc_insertion_point(field_add:pg_query.RTEPermissionInfo.updated_cols)
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& RTEPermissionInfo::updated_cols() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RTEPermissionInfo.updated_cols)
  return _internal_updated_cols();
}
inline ::google::protobuf::RepeatedField<::uint64_t>* RTEPermissionInfo::mutable_updated_cols()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RTEPermissionInfo.updated_cols)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_updated_cols();
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& RTEPermissionInfo::_internal_updated_cols()
    const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.updated_cols_;
}
inline ::google::protobuf::RepeatedField<::uint64_t>* RTEPermissionInfo::_internal_mutable_updated_cols() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.updated_cols_;
}

// -------------------------------------------------------------------

// RangeTblFunction

// .pg_query.Node funcexpr = 1 [json_name = "funcexpr"];
inline bool RangeTblFunction::has_funcexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.funcexpr_ != nullptr);
  return value;
}
inline void RangeTblFunction::clear_funcexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.funcexpr_ != nullptr) _impl_.funcexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& RangeTblFunction::_internal_funcexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.funcexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RangeTblFunction::funcexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funcexpr)
  return _internal_funcexpr();
}
inline void RangeTblFunction::unsafe_arena_set_allocated_funcexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.funcexpr_);
  }
  _impl_.funcexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblFunction.funcexpr)
}
inline ::pg_query::Node* RangeTblFunction::release_funcexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.funcexpr_;
  _impl_.funcexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RangeTblFunction::unsafe_arena_release_funcexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RangeTblFunction.funcexpr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.funcexpr_;
  _impl_.funcexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RangeTblFunction::_internal_mutable_funcexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.funcexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.funcexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.funcexpr_;
}
inline ::pg_query::Node* RangeTblFunction::mutable_funcexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_funcexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funcexpr)
  return _msg;
}
inline void RangeTblFunction::set_allocated_funcexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.funcexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.funcexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblFunction.funcexpr)
}

// int32 funccolcount = 2 [json_name = "funccolcount"];
inline void RangeTblFunction::clear_funccolcount() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funccolcount_ = 0;
}
inline ::int32_t RangeTblFunction::funccolcount() const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccolcount)
  return _internal_funccolcount();
}
inline void RangeTblFunction::set_funccolcount(::int32_t value) {
  _internal_set_funccolcount(value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblFunction.funccolcount)
}
inline ::int32_t RangeTblFunction::_internal_funccolcount() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funccolcount_;
}
inline void RangeTblFunction::_internal_set_funccolcount(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.funccolcount_ = value;
}

// repeated .pg_query.Node funccolnames = 3 [json_name = "funccolnames"];
inline int RangeTblFunction::_internal_funccolnames_size() const {
  return _internal_funccolnames().size();
}
inline int RangeTblFunction::funccolnames_size() const {
  return _internal_funccolnames_size();
}
inline void RangeTblFunction::clear_funccolnames() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funccolnames_.Clear();
}
inline ::pg_query::Node* RangeTblFunction::mutable_funccolnames(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funccolnames)
  return _internal_mutable_funccolnames()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblFunction::mutable_funccolnames()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funccolnames)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_funccolnames();
}
inline const ::pg_query::Node& RangeTblFunction::funccolnames(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccolnames)
  return _internal_funccolnames().Get(index);
}
inline ::pg_query::Node* RangeTblFunction::add_funccolnames() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_funccolnames()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funccolnames)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblFunction::funccolnames() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funccolnames)
  return _internal_funccolnames();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblFunction::_internal_funccolnames() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funccolnames_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblFunction::_internal_mutable_funccolnames() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.funccolnames_;
}

// repeated .pg_query.Node funccoltypes = 4 [json_name = "funccoltypes"];
inline int RangeTblFunction::_internal_funccoltypes_size() const {
  return _internal_funccoltypes().size();
}
inline int RangeTblFunction::funccoltypes_size() const {
  return _internal_funccoltypes_size();
}
inline void RangeTblFunction::clear_funccoltypes() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funccoltypes_.Clear();
}
inline ::pg_query::Node* RangeTblFunction::mutable_funccoltypes(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funccoltypes)
  return _internal_mutable_funccoltypes()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblFunction::mutable_funccoltypes()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funccoltypes)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_funccoltypes();
}
inline const ::pg_query::Node& RangeTblFunction::funccoltypes(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccoltypes)
  return _internal_funccoltypes().Get(index);
}
inline ::pg_query::Node* RangeTblFunction::add_funccoltypes() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_funccoltypes()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funccoltypes)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblFunction::funccoltypes() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funccoltypes)
  return _internal_funccoltypes();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblFunction::_internal_funccoltypes() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funccoltypes_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblFunction::_internal_mutable_funccoltypes() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.funccoltypes_;
}

// repeated .pg_query.Node funccoltypmods = 5 [json_name = "funccoltypmods"];
inline int RangeTblFunction::_internal_funccoltypmods_size() const {
  return _internal_funccoltypmods().size();
}
inline int RangeTblFunction::funccoltypmods_size() const {
  return _internal_funccoltypmods_size();
}
inline void RangeTblFunction::clear_funccoltypmods() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funccoltypmods_.Clear();
}
inline ::pg_query::Node* RangeTblFunction::mutable_funccoltypmods(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funccoltypmods)
  return _internal_mutable_funccoltypmods()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblFunction::mutable_funccoltypmods()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funccoltypmods)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_funccoltypmods();
}
inline const ::pg_query::Node& RangeTblFunction::funccoltypmods(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccoltypmods)
  return _internal_funccoltypmods().Get(index);
}
inline ::pg_query::Node* RangeTblFunction::add_funccoltypmods() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_funccoltypmods()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funccoltypmods)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblFunction::funccoltypmods() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funccoltypmods)
  return _internal_funccoltypmods();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblFunction::_internal_funccoltypmods() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funccoltypmods_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblFunction::_internal_mutable_funccoltypmods() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.funccoltypmods_;
}

// repeated .pg_query.Node funccolcollations = 6 [json_name = "funccolcollations"];
inline int RangeTblFunction::_internal_funccolcollations_size() const {
  return _internal_funccolcollations().size();
}
inline int RangeTblFunction::funccolcollations_size() const {
  return _internal_funccolcollations_size();
}
inline void RangeTblFunction::clear_funccolcollations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funccolcollations_.Clear();
}
inline ::pg_query::Node* RangeTblFunction::mutable_funccolcollations(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funccolcollations)
  return _internal_mutable_funccolcollations()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RangeTblFunction::mutable_funccolcollations()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funccolcollations)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_funccolcollations();
}
inline const ::pg_query::Node& RangeTblFunction::funccolcollations(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccolcollations)
  return _internal_funccolcollations().Get(index);
}
inline ::pg_query::Node* RangeTblFunction::add_funccolcollations() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_funccolcollations()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funccolcollations)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RangeTblFunction::funccolcollations() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funccolcollations)
  return _internal_funccolcollations();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RangeTblFunction::_internal_funccolcollations() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funccolcollations_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RangeTblFunction::_internal_mutable_funccolcollations() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.funccolcollations_;
}

// repeated uint64 funcparams = 7 [json_name = "funcparams"];
inline int RangeTblFunction::_internal_funcparams_size() const {
  return _internal_funcparams().size();
}
inline int RangeTblFunction::funcparams_size() const {
  return _internal_funcparams_size();
}
inline void RangeTblFunction::clear_funcparams() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funcparams_.Clear();
}
inline ::uint64_t RangeTblFunction::funcparams(int index) const {
  // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funcparams)
  return _internal_funcparams().Get(index);
}
inline void RangeTblFunction::set_funcparams(int index, ::uint64_t value) {
  _internal_mutable_funcparams()->Set(index, value);
  // @@protoc_insertion_point(field_set:pg_query.RangeTblFunction.funcparams)
}
inline void RangeTblFunction::add_funcparams(::uint64_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_funcparams()->Add(value);
  // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funcparams)
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& RangeTblFunction::funcparams() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funcparams)
  return _internal_funcparams();
}
inline ::google::protobuf::RepeatedField<::uint64_t>* RangeTblFunction::mutable_funcparams()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funcparams)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_funcparams();
}
inline const ::google::protobuf::RepeatedField<::uint64_t>& RangeTblFunction::_internal_funcparams()
    const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funcparams_;
}
inline ::google::protobuf::RepeatedField<::uint64_t>* RangeTblFunction::_internal_mutable_funcparams() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.funcparams_;
}

// -------------------------------------------------------------------

// TableSampleClause

// uint32 tsmhandler = 1 [json_name = "tsmhandler"];
inline void TableSampleClause::clear_tsmhandler() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tsmhandler_ = 0u;
}
inline ::uint32_t TableSampleClause::tsmhandler() const {
  // @@protoc_insertion_point(field_get:pg_query.TableSampleClause.tsmhandler)
  return _internal_tsmhandler();
}
inline void TableSampleClause::set_tsmhandler(::uint32_t value) {
  _internal_set_tsmhandler(value);
  // @@protoc_insertion_point(field_set:pg_query.TableSampleClause.tsmhandler)
}
inline ::uint32_t TableSampleClause::_internal_tsmhandler() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.tsmhandler_;
}
inline void TableSampleClause::_internal_set_tsmhandler(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.tsmhandler_ = value;
}

// repeated .pg_query.Node args = 2 [json_name = "args"];
inline int TableSampleClause::_internal_args_size() const {
  return _internal_args().size();
}
inline int TableSampleClause::args_size() const {
  return _internal_args_size();
}
inline void TableSampleClause::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* TableSampleClause::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TableSampleClause.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TableSampleClause::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TableSampleClause.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& TableSampleClause::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableSampleClause.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* TableSampleClause::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TableSampleClause.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TableSampleClause::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TableSampleClause.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TableSampleClause::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TableSampleClause::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// .pg_query.Node repeatable = 3 [json_name = "repeatable"];
inline bool TableSampleClause::has_repeatable() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.repeatable_ != nullptr);
  return value;
}
inline void TableSampleClause::clear_repeatable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.repeatable_ != nullptr) _impl_.repeatable_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& TableSampleClause::_internal_repeatable() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.repeatable_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& TableSampleClause::repeatable() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TableSampleClause.repeatable)
  return _internal_repeatable();
}
inline void TableSampleClause::unsafe_arena_set_allocated_repeatable(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.repeatable_);
  }
  _impl_.repeatable_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TableSampleClause.repeatable)
}
inline ::pg_query::Node* TableSampleClause::release_repeatable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.repeatable_;
  _impl_.repeatable_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* TableSampleClause::unsafe_arena_release_repeatable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.TableSampleClause.repeatable)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.repeatable_;
  _impl_.repeatable_ = nullptr;
  return temp;
}
inline ::pg_query::Node* TableSampleClause::_internal_mutable_repeatable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.repeatable_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.repeatable_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.repeatable_;
}
inline ::pg_query::Node* TableSampleClause::mutable_repeatable() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_repeatable();
  // @@protoc_insertion_point(field_mutable:pg_query.TableSampleClause.repeatable)
  return _msg;
}
inline void TableSampleClause::set_allocated_repeatable(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.repeatable_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.repeatable_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.TableSampleClause.repeatable)
}

// -------------------------------------------------------------------

// WithCheckOption

// .pg_query.WCOKind kind = 1 [json_name = "kind"];
inline void WithCheckOption::clear_kind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.kind_ = 0;
}
inline ::pg_query::WCOKind WithCheckOption::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.kind)
  return _internal_kind();
}
inline void WithCheckOption::set_kind(::pg_query::WCOKind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.WithCheckOption.kind)
}
inline ::pg_query::WCOKind WithCheckOption::_internal_kind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::WCOKind>(_impl_.kind_);
}
inline void WithCheckOption::_internal_set_kind(::pg_query::WCOKind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.kind_ = value;
}

// string relname = 2 [json_name = "relname"];
inline void WithCheckOption::clear_relname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relname_.ClearToEmpty();
}
inline const std::string& WithCheckOption::relname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.relname)
  return _internal_relname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void WithCheckOption::set_relname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.WithCheckOption.relname)
}
inline std::string* WithCheckOption::mutable_relname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_relname();
  // @@protoc_insertion_point(field_mutable:pg_query.WithCheckOption.relname)
  return _s;
}
inline const std::string& WithCheckOption::_internal_relname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.relname_.Get();
}
inline void WithCheckOption::_internal_set_relname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relname_.Set(value, GetArena());
}
inline std::string* WithCheckOption::_internal_mutable_relname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.relname_.Mutable( GetArena());
}
inline std::string* WithCheckOption::release_relname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WithCheckOption.relname)
  return _impl_.relname_.Release();
}
inline void WithCheckOption::set_allocated_relname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.relname_.IsDefault()) {
          _impl_.relname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.WithCheckOption.relname)
}

// string polname = 3 [json_name = "polname"];
inline void WithCheckOption::clear_polname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.polname_.ClearToEmpty();
}
inline const std::string& WithCheckOption::polname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.polname)
  return _internal_polname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void WithCheckOption::set_polname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.polname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.WithCheckOption.polname)
}
inline std::string* WithCheckOption::mutable_polname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_polname();
  // @@protoc_insertion_point(field_mutable:pg_query.WithCheckOption.polname)
  return _s;
}
inline const std::string& WithCheckOption::_internal_polname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.polname_.Get();
}
inline void WithCheckOption::_internal_set_polname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.polname_.Set(value, GetArena());
}
inline std::string* WithCheckOption::_internal_mutable_polname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.polname_.Mutable( GetArena());
}
inline std::string* WithCheckOption::release_polname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WithCheckOption.polname)
  return _impl_.polname_.Release();
}
inline void WithCheckOption::set_allocated_polname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.polname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.polname_.IsDefault()) {
          _impl_.polname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.WithCheckOption.polname)
}

// .pg_query.Node qual = 4 [json_name = "qual"];
inline bool WithCheckOption::has_qual() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.qual_ != nullptr);
  return value;
}
inline void WithCheckOption::clear_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.qual_ != nullptr) _impl_.qual_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& WithCheckOption::_internal_qual() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.qual_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& WithCheckOption::qual() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.qual)
  return _internal_qual();
}
inline void WithCheckOption::unsafe_arena_set_allocated_qual(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.qual_);
  }
  _impl_.qual_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WithCheckOption.qual)
}
inline ::pg_query::Node* WithCheckOption::release_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.qual_;
  _impl_.qual_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* WithCheckOption::unsafe_arena_release_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WithCheckOption.qual)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.qual_;
  _impl_.qual_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WithCheckOption::_internal_mutable_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.qual_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.qual_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.qual_;
}
inline ::pg_query::Node* WithCheckOption::mutable_qual() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_qual();
  // @@protoc_insertion_point(field_mutable:pg_query.WithCheckOption.qual)
  return _msg;
}
inline void WithCheckOption::set_allocated_qual(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.qual_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.qual_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.WithCheckOption.qual)
}

// bool cascaded = 5 [json_name = "cascaded"];
inline void WithCheckOption::clear_cascaded() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cascaded_ = false;
}
inline bool WithCheckOption::cascaded() const {
  // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.cascaded)
  return _internal_cascaded();
}
inline void WithCheckOption::set_cascaded(bool value) {
  _internal_set_cascaded(value);
  // @@protoc_insertion_point(field_set:pg_query.WithCheckOption.cascaded)
}
inline bool WithCheckOption::_internal_cascaded() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cascaded_;
}
inline void WithCheckOption::_internal_set_cascaded(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cascaded_ = value;
}

// -------------------------------------------------------------------

// SortGroupClause

// uint32 tle_sort_group_ref = 1 [json_name = "tleSortGroupRef"];
inline void SortGroupClause::clear_tle_sort_group_ref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tle_sort_group_ref_ = 0u;
}
inline ::uint32_t 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::set_tle_sort_group_ref(::uint32_t value) {
  _internal_set_tle_sort_group_ref(value);
  // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.tle_sort_group_ref)
}
inline ::uint32_t SortGroupClause::_internal_tle_sort_group_ref() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.tle_sort_group_ref_;
}
inline void SortGroupClause::_internal_set_tle_sort_group_ref(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.tle_sort_group_ref_ = value;
}

// uint32 eqop = 2 [json_name = "eqop"];
inline void SortGroupClause::clear_eqop() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.eqop_ = 0u;
}
inline ::uint32_t SortGroupClause::eqop() const {
  // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.eqop)
  return _internal_eqop();
}
inline void SortGroupClause::set_eqop(::uint32_t value) {
  _internal_set_eqop(value);
  // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.eqop)
}
inline ::uint32_t SortGroupClause::_internal_eqop() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.eqop_;
}
inline void SortGroupClause::_internal_set_eqop(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.eqop_ = value;
}

// uint32 sortop = 3 [json_name = "sortop"];
inline void SortGroupClause::clear_sortop() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.sortop_ = 0u;
}
inline ::uint32_t SortGroupClause::sortop() const {
  // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.sortop)
  return _internal_sortop();
}
inline void SortGroupClause::set_sortop(::uint32_t value) {
  _internal_set_sortop(value);
  // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.sortop)
}
inline ::uint32_t SortGroupClause::_internal_sortop() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.sortop_;
}
inline void SortGroupClause::_internal_set_sortop(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.sortop_ = value;
}

// bool nulls_first = 4 [json_name = "nulls_first"];
inline void SortGroupClause::clear_nulls_first() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.nulls_first_ = false;
}
inline bool SortGroupClause::nulls_first() const {
  // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.nulls_first)
  return _internal_nulls_first();
}
inline void SortGroupClause::set_nulls_first(bool value) {
  _internal_set_nulls_first(value);
  // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.nulls_first)
}
inline bool SortGroupClause::_internal_nulls_first() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.nulls_first_;
}
inline void SortGroupClause::_internal_set_nulls_first(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.nulls_first_ = value;
}

// bool hashable = 5 [json_name = "hashable"];
inline void SortGroupClause::clear_hashable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.hashable_ = false;
}
inline bool SortGroupClause::hashable() const {
  // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.hashable)
  return _internal_hashable();
}
inline void SortGroupClause::set_hashable(bool value) {
  _internal_set_hashable(value);
  // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.hashable)
}
inline bool SortGroupClause::_internal_hashable() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.hashable_;
}
inline void SortGroupClause::_internal_set_hashable(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.hashable_ = value;
}

// -------------------------------------------------------------------

// GroupingSet

// .pg_query.GroupingSetKind kind = 1 [json_name = "kind"];
inline void GroupingSet::clear_kind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.kind_ = 0;
}
inline ::pg_query::GroupingSetKind GroupingSet::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingSet.kind)
  return _internal_kind();
}
inline void GroupingSet::set_kind(::pg_query::GroupingSetKind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.GroupingSet.kind)
}
inline ::pg_query::GroupingSetKind GroupingSet::_internal_kind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::GroupingSetKind>(_impl_.kind_);
}
inline void GroupingSet::_internal_set_kind(::pg_query::GroupingSetKind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.kind_ = value;
}

// repeated .pg_query.Node content = 2 [json_name = "content"];
inline int GroupingSet::_internal_content_size() const {
  return _internal_content().size();
}
inline int GroupingSet::content_size() const {
  return _internal_content_size();
}
inline void GroupingSet::clear_content() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.content_.Clear();
}
inline ::pg_query::Node* GroupingSet::mutable_content(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.GroupingSet.content)
  return _internal_mutable_content()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* GroupingSet::mutable_content()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GroupingSet.content)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_content();
}
inline const ::pg_query::Node& GroupingSet::content(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.GroupingSet.content)
  return _internal_content().Get(index);
}
inline ::pg_query::Node* GroupingSet::add_content() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_content()->Add();
  // @@protoc_insertion_point(field_add:pg_query.GroupingSet.content)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& GroupingSet::content() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.GroupingSet.content)
  return _internal_content();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
GroupingSet::_internal_content() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.content_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
GroupingSet::_internal_mutable_content() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.content_;
}

// int32 location = 3 [json_name = "location"];
inline void GroupingSet::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t GroupingSet::location() const {
  // @@protoc_insertion_point(field_get:pg_query.GroupingSet.location)
  return _internal_location();
}
inline void GroupingSet::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.GroupingSet.location)
}
inline ::int32_t GroupingSet::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void GroupingSet::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// WindowClause

// string name = 1 [json_name = "name"];
inline void WindowClause::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& WindowClause::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void WindowClause::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.name)
}
inline std::string* WindowClause::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.name)
  return _s;
}
inline const std::string& WindowClause::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void WindowClause::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* WindowClause::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* WindowClause::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WindowClause.name)
  return _impl_.name_.Release();
}
inline void WindowClause::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowClause.name)
}

// string refname = 2 [json_name = "refname"];
inline void WindowClause::clear_refname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.refname_.ClearToEmpty();
}
inline const std::string& WindowClause::refname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.refname)
  return _internal_refname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void WindowClause::set_refname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.refname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.refname)
}
inline std::string* WindowClause::mutable_refname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_refname();
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.refname)
  return _s;
}
inline const std::string& WindowClause::_internal_refname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.refname_.Get();
}
inline void WindowClause::_internal_set_refname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.refname_.Set(value, GetArena());
}
inline std::string* WindowClause::_internal_mutable_refname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.refname_.Mutable( GetArena());
}
inline std::string* WindowClause::release_refname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WindowClause.refname)
  return _impl_.refname_.Release();
}
inline void WindowClause::set_allocated_refname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.refname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.refname_.IsDefault()) {
          _impl_.refname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_partition_clause().size();
}
inline int WindowClause::partition_clause_size() const {
  return _internal_partition_clause_size();
}
inline void WindowClause::clear_partition_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.partition_clause_.Clear();
}
inline ::pg_query::Node* WindowClause::mutable_partition_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.partition_clause)
  return _internal_mutable_partition_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* WindowClause::mutable_partition_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WindowClause.partition_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_partition_clause();
}
inline const ::pg_query::Node& WindowClause::partition_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.partition_clause)
  return _internal_partition_clause().Get(index);
}
inline ::pg_query::Node* WindowClause::add_partition_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_partition_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.WindowClause.partition_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& WindowClause::partition_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.WindowClause.partition_clause)
  return _internal_partition_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
WindowClause::_internal_partition_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.partition_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
WindowClause::_internal_mutable_partition_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.partition_clause_;
}

// repeated .pg_query.Node order_clause = 4 [json_name = "orderClause"];
inline int WindowClause::_internal_order_clause_size() const {
  return _internal_order_clause().size();
}
inline int WindowClause::order_clause_size() const {
  return _internal_order_clause_size();
}
inline void WindowClause::clear_order_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.order_clause_.Clear();
}
inline ::pg_query::Node* WindowClause::mutable_order_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.order_clause)
  return _internal_mutable_order_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* WindowClause::mutable_order_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WindowClause.order_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_order_clause();
}
inline const ::pg_query::Node& WindowClause::order_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.order_clause)
  return _internal_order_clause().Get(index);
}
inline ::pg_query::Node* WindowClause::add_order_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_order_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.WindowClause.order_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& WindowClause::order_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.WindowClause.order_clause)
  return _internal_order_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
WindowClause::_internal_order_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.order_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
WindowClause::_internal_mutable_order_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.order_clause_;
}

// int32 frame_options = 5 [json_name = "frameOptions"];
inline void WindowClause::clear_frame_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.frame_options_ = 0;
}
inline ::int32_t WindowClause::frame_options() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.frame_options)
  return _internal_frame_options();
}
inline void WindowClause::set_frame_options(::int32_t value) {
  _internal_set_frame_options(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.frame_options)
}
inline ::int32_t WindowClause::_internal_frame_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.frame_options_;
}
inline void WindowClause::_internal_set_frame_options(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.frame_options_ = value;
}

// .pg_query.Node start_offset = 6 [json_name = "startOffset"];
inline bool WindowClause::has_start_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.start_offset_ != nullptr);
  return value;
}
inline void WindowClause::clear_start_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.start_offset_ != nullptr) _impl_.start_offset_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& WindowClause::_internal_start_offset() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.start_offset_);
  }
  _impl_.start_offset_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowClause.start_offset)
}
inline ::pg_query::Node* WindowClause::release_start_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.start_offset_;
  _impl_.start_offset_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* WindowClause::unsafe_arena_release_start_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WindowClause.start_offset)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.start_offset_;
  _impl_.start_offset_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WindowClause::_internal_mutable_start_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.start_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.start_offset_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.start_offset_;
}
inline ::pg_query::Node* WindowClause::mutable_start_offset() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_start_offset();
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.start_offset)
  return _msg;
}
inline void WindowClause::set_allocated_start_offset(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.start_offset_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.start_offset_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowClause.start_offset)
}

// .pg_query.Node end_offset = 7 [json_name = "endOffset"];
inline bool WindowClause::has_end_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.end_offset_ != nullptr);
  return value;
}
inline void WindowClause::clear_end_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.end_offset_ != nullptr) _impl_.end_offset_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& WindowClause::_internal_end_offset() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.end_offset_);
  }
  _impl_.end_offset_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowClause.end_offset)
}
inline ::pg_query::Node* WindowClause::release_end_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.end_offset_;
  _impl_.end_offset_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* WindowClause::unsafe_arena_release_end_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.WindowClause.end_offset)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.end_offset_;
  _impl_.end_offset_ = nullptr;
  return temp;
}
inline ::pg_query::Node* WindowClause::_internal_mutable_end_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.end_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.end_offset_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.end_offset_;
}
inline ::pg_query::Node* WindowClause::mutable_end_offset() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_end_offset();
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.end_offset)
  return _msg;
}
inline void WindowClause::set_allocated_end_offset(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.end_offset_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.end_offset_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.WindowClause.end_offset)
}

// repeated .pg_query.Node run_condition = 8 [json_name = "runCondition"];
inline int WindowClause::_internal_run_condition_size() const {
  return _internal_run_condition().size();
}
inline int WindowClause::run_condition_size() const {
  return _internal_run_condition_size();
}
inline void WindowClause::clear_run_condition() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.run_condition_.Clear();
}
inline ::pg_query::Node* WindowClause::mutable_run_condition(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.run_condition)
  return _internal_mutable_run_condition()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* WindowClause::mutable_run_condition()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WindowClause.run_condition)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_run_condition();
}
inline const ::pg_query::Node& WindowClause::run_condition(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.run_condition)
  return _internal_run_condition().Get(index);
}
inline ::pg_query::Node* WindowClause::add_run_condition() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_run_condition()->Add();
  // @@protoc_insertion_point(field_add:pg_query.WindowClause.run_condition)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& WindowClause::run_condition() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.WindowClause.run_condition)
  return _internal_run_condition();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
WindowClause::_internal_run_condition() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.run_condition_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
WindowClause::_internal_mutable_run_condition() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.run_condition_;
}

// uint32 start_in_range_func = 9 [json_name = "startInRangeFunc"];
inline void WindowClause::clear_start_in_range_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.start_in_range_func_ = 0u;
}
inline ::uint32_t 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::set_start_in_range_func(::uint32_t value) {
  _internal_set_start_in_range_func(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.start_in_range_func)
}
inline ::uint32_t WindowClause::_internal_start_in_range_func() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.start_in_range_func_;
}
inline void WindowClause::_internal_set_start_in_range_func(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.start_in_range_func_ = value;
}

// uint32 end_in_range_func = 10 [json_name = "endInRangeFunc"];
inline void WindowClause::clear_end_in_range_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.end_in_range_func_ = 0u;
}
inline ::uint32_t 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::set_end_in_range_func(::uint32_t value) {
  _internal_set_end_in_range_func(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.end_in_range_func)
}
inline ::uint32_t WindowClause::_internal_end_in_range_func() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.end_in_range_func_;
}
inline void WindowClause::_internal_set_end_in_range_func(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.end_in_range_func_ = value;
}

// uint32 in_range_coll = 11 [json_name = "inRangeColl"];
inline void WindowClause::clear_in_range_coll() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.in_range_coll_ = 0u;
}
inline ::uint32_t WindowClause::in_range_coll() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.in_range_coll)
  return _internal_in_range_coll();
}
inline void WindowClause::set_in_range_coll(::uint32_t value) {
  _internal_set_in_range_coll(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.in_range_coll)
}
inline ::uint32_t WindowClause::_internal_in_range_coll() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.in_range_coll_;
}
inline void WindowClause::_internal_set_in_range_coll(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.in_range_coll_ = value;
}

// bool in_range_asc = 12 [json_name = "inRangeAsc"];
inline void WindowClause::clear_in_range_asc() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.in_range_asc_ = false;
}
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::set_in_range_asc(bool value) {
  _internal_set_in_range_asc(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.in_range_asc)
}
inline bool WindowClause::_internal_in_range_asc() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.in_range_asc_;
}
inline void WindowClause::_internal_set_in_range_asc(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.in_range_asc_ = value;
}

// bool in_range_nulls_first = 13 [json_name = "inRangeNullsFirst"];
inline void WindowClause::clear_in_range_nulls_first() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.in_range_nulls_first_ = false;
}
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::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)
}
inline bool WindowClause::_internal_in_range_nulls_first() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.in_range_nulls_first_;
}
inline void WindowClause::_internal_set_in_range_nulls_first(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.in_range_nulls_first_ = value;
}

// uint32 winref = 14 [json_name = "winref"];
inline void WindowClause::clear_winref() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.winref_ = 0u;
}
inline ::uint32_t WindowClause::winref() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.winref)
  return _internal_winref();
}
inline void WindowClause::set_winref(::uint32_t value) {
  _internal_set_winref(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.winref)
}
inline ::uint32_t WindowClause::_internal_winref() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.winref_;
}
inline void WindowClause::_internal_set_winref(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.winref_ = value;
}

// bool copied_order = 15 [json_name = "copiedOrder"];
inline void WindowClause::clear_copied_order() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.copied_order_ = false;
}
inline bool WindowClause::copied_order() const {
  // @@protoc_insertion_point(field_get:pg_query.WindowClause.copied_order)
  return _internal_copied_order();
}
inline void WindowClause::set_copied_order(bool value) {
  _internal_set_copied_order(value);
  // @@protoc_insertion_point(field_set:pg_query.WindowClause.copied_order)
}
inline bool WindowClause::_internal_copied_order() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.copied_order_;
}
inline void WindowClause::_internal_set_copied_order(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.copied_order_ = value;
}

// -------------------------------------------------------------------

// RowMarkClause

// uint32 rti = 1 [json_name = "rti"];
inline void RowMarkClause::clear_rti() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rti_ = 0u;
}
inline ::uint32_t RowMarkClause::rti() const {
  // @@protoc_insertion_point(field_get:pg_query.RowMarkClause.rti)
  return _internal_rti();
}
inline void RowMarkClause::set_rti(::uint32_t value) {
  _internal_set_rti(value);
  // @@protoc_insertion_point(field_set:pg_query.RowMarkClause.rti)
}
inline ::uint32_t RowMarkClause::_internal_rti() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.rti_;
}
inline void RowMarkClause::_internal_set_rti(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.rti_ = value;
}

// .pg_query.LockClauseStrength strength = 2 [json_name = "strength"];
inline void RowMarkClause::clear_strength() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.strength_ = 0;
}
inline ::pg_query::LockClauseStrength RowMarkClause::strength() const {
  // @@protoc_insertion_point(field_get:pg_query.RowMarkClause.strength)
  return _internal_strength();
}
inline void RowMarkClause::set_strength(::pg_query::LockClauseStrength value) {
  _internal_set_strength(value);
  // @@protoc_insertion_point(field_set:pg_query.RowMarkClause.strength)
}
inline ::pg_query::LockClauseStrength RowMarkClause::_internal_strength() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::LockClauseStrength>(_impl_.strength_);
}
inline void RowMarkClause::_internal_set_strength(::pg_query::LockClauseStrength value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.strength_ = value;
}

// .pg_query.LockWaitPolicy wait_policy = 3 [json_name = "waitPolicy"];
inline void RowMarkClause::clear_wait_policy() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.wait_policy_ = 0;
}
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::set_wait_policy(::pg_query::LockWaitPolicy value) {
  _internal_set_wait_policy(value);
  // @@protoc_insertion_point(field_set:pg_query.RowMarkClause.wait_policy)
}
inline ::pg_query::LockWaitPolicy RowMarkClause::_internal_wait_policy() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::LockWaitPolicy>(_impl_.wait_policy_);
}
inline void RowMarkClause::_internal_set_wait_policy(::pg_query::LockWaitPolicy value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.wait_policy_ = value;
}

// bool pushed_down = 4 [json_name = "pushedDown"];
inline void RowMarkClause::clear_pushed_down() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.pushed_down_ = false;
}
inline bool RowMarkClause::pushed_down() const {
  // @@protoc_insertion_point(field_get:pg_query.RowMarkClause.pushed_down)
  return _internal_pushed_down();
}
inline void RowMarkClause::set_pushed_down(bool value) {
  _internal_set_pushed_down(value);
  // @@protoc_insertion_point(field_set:pg_query.RowMarkClause.pushed_down)
}
inline bool RowMarkClause::_internal_pushed_down() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.pushed_down_;
}
inline void RowMarkClause::_internal_set_pushed_down(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.pushed_down_ = value;
}

// -------------------------------------------------------------------

// WithClause

// repeated .pg_query.Node ctes = 1 [json_name = "ctes"];
inline int WithClause::_internal_ctes_size() const {
  return _internal_ctes().size();
}
inline int WithClause::ctes_size() const {
  return _internal_ctes_size();
}
inline void WithClause::clear_ctes() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ctes_.Clear();
}
inline ::pg_query::Node* WithClause::mutable_ctes(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.WithClause.ctes)
  return _internal_mutable_ctes()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* WithClause::mutable_ctes()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.WithClause.ctes)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_ctes();
}
inline const ::pg_query::Node& WithClause::ctes(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.WithClause.ctes)
  return _internal_ctes().Get(index);
}
inline ::pg_query::Node* WithClause::add_ctes() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_ctes()->Add();
  // @@protoc_insertion_point(field_add:pg_query.WithClause.ctes)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& WithClause::ctes() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.WithClause.ctes)
  return _internal_ctes();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
WithClause::_internal_ctes() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ctes_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
WithClause::_internal_mutable_ctes() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.ctes_;
}

// bool recursive = 2 [json_name = "recursive"];
inline void WithClause::clear_recursive() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.recursive_ = false;
}
inline bool WithClause::recursive() const {
  // @@protoc_insertion_point(field_get:pg_query.WithClause.recursive)
  return _internal_recursive();
}
inline void WithClause::set_recursive(bool value) {
  _internal_set_recursive(value);
  // @@protoc_insertion_point(field_set:pg_query.WithClause.recursive)
}
inline bool WithClause::_internal_recursive() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.recursive_;
}
inline void WithClause::_internal_set_recursive(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.recursive_ = value;
}

// int32 location = 3 [json_name = "location"];
inline void WithClause::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t WithClause::location() const {
  // @@protoc_insertion_point(field_get:pg_query.WithClause.location)
  return _internal_location();
}
inline void WithClause::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.WithClause.location)
}
inline ::int32_t WithClause::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void WithClause::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// InferClause

// repeated .pg_query.Node index_elems = 1 [json_name = "indexElems"];
inline int InferClause::_internal_index_elems_size() const {
  return _internal_index_elems().size();
}
inline int InferClause::index_elems_size() const {
  return _internal_index_elems_size();
}
inline void InferClause::clear_index_elems() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.index_elems_.Clear();
}
inline ::pg_query::Node* InferClause::mutable_index_elems(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.InferClause.index_elems)
  return _internal_mutable_index_elems()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* InferClause::mutable_index_elems()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.InferClause.index_elems)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_index_elems();
}
inline const ::pg_query::Node& InferClause::index_elems(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.InferClause.index_elems)
  return _internal_index_elems().Get(index);
}
inline ::pg_query::Node* InferClause::add_index_elems() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_index_elems()->Add();
  // @@protoc_insertion_point(field_add:pg_query.InferClause.index_elems)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& InferClause::index_elems() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.InferClause.index_elems)
  return _internal_index_elems();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
InferClause::_internal_index_elems() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.index_elems_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
InferClause::_internal_mutable_index_elems() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.index_elems_;
}

// .pg_query.Node where_clause = 2 [json_name = "whereClause"];
inline bool InferClause::has_where_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.where_clause_ != nullptr);
  return value;
}
inline void InferClause::clear_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.where_clause_ != nullptr) _impl_.where_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& InferClause::_internal_where_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.where_clause_);
  }
  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InferClause.where_clause)
}
inline ::pg_query::Node* InferClause::release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* InferClause::unsafe_arena_release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.InferClause.where_clause)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* InferClause::_internal_mutable_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.where_clause_;
}
inline ::pg_query::Node* InferClause::mutable_where_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_where_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.InferClause.where_clause)
  return _msg;
}
inline void InferClause::set_allocated_where_clause(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.where_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.InferClause.where_clause)
}

// string conname = 3 [json_name = "conname"];
inline void InferClause::clear_conname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conname_.ClearToEmpty();
}
inline const std::string& InferClause::conname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.InferClause.conname)
  return _internal_conname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void InferClause::set_conname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.InferClause.conname)
}
inline std::string* InferClause::mutable_conname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_conname();
  // @@protoc_insertion_point(field_mutable:pg_query.InferClause.conname)
  return _s;
}
inline const std::string& InferClause::_internal_conname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.conname_.Get();
}
inline void InferClause::_internal_set_conname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conname_.Set(value, GetArena());
}
inline std::string* InferClause::_internal_mutable_conname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.conname_.Mutable( GetArena());
}
inline std::string* InferClause::release_conname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.InferClause.conname)
  return _impl_.conname_.Release();
}
inline void InferClause::set_allocated_conname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.conname_.IsDefault()) {
          _impl_.conname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.InferClause.conname)
}

// int32 location = 4 [json_name = "location"];
inline void InferClause::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t InferClause::location() const {
  // @@protoc_insertion_point(field_get:pg_query.InferClause.location)
  return _internal_location();
}
inline void InferClause::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.InferClause.location)
}
inline ::int32_t InferClause::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void InferClause::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// OnConflictClause

// .pg_query.OnConflictAction action = 1 [json_name = "action"];
inline void OnConflictClause::clear_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.action_ = 0;
}
inline ::pg_query::OnConflictAction OnConflictClause::action() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.action)
  return _internal_action();
}
inline void OnConflictClause::set_action(::pg_query::OnConflictAction value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:pg_query.OnConflictClause.action)
}
inline ::pg_query::OnConflictAction OnConflictClause::_internal_action() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::OnConflictAction>(_impl_.action_);
}
inline void OnConflictClause::_internal_set_action(::pg_query::OnConflictAction value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.action_ = value;
}

// .pg_query.InferClause infer = 2 [json_name = "infer"];
inline bool OnConflictClause::has_infer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.infer_ != nullptr);
  return value;
}
inline void OnConflictClause::clear_infer() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.infer_ != nullptr) _impl_.infer_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::InferClause& OnConflictClause::_internal_infer() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::InferClause* p = _impl_.infer_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::InferClause&>(::pg_query::_InferClause_default_instance_);
}
inline const ::pg_query::InferClause& OnConflictClause::infer() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.infer)
  return _internal_infer();
}
inline void OnConflictClause::unsafe_arena_set_allocated_infer(::pg_query::InferClause* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.infer_);
  }
  _impl_.infer_ = reinterpret_cast<::pg_query::InferClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OnConflictClause.infer)
}
inline ::pg_query::InferClause* OnConflictClause::release_infer() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::InferClause* released = _impl_.infer_;
  _impl_.infer_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::InferClause* OnConflictClause::unsafe_arena_release_infer() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.OnConflictClause.infer)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::InferClause* temp = _impl_.infer_;
  _impl_.infer_ = nullptr;
  return temp;
}
inline ::pg_query::InferClause* OnConflictClause::_internal_mutable_infer() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.infer_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::InferClause>(GetArena());
    _impl_.infer_ = reinterpret_cast<::pg_query::InferClause*>(p);
  }
  return _impl_.infer_;
}
inline ::pg_query::InferClause* OnConflictClause::mutable_infer() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::InferClause* _msg = _internal_mutable_infer();
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictClause.infer)
  return _msg;
}
inline void OnConflictClause::set_allocated_infer(::pg_query::InferClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::InferClause*>(_impl_.infer_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::InferClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.infer_ = reinterpret_cast<::pg_query::InferClause*>(value);
  // @@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 _internal_target_list().size();
}
inline int OnConflictClause::target_list_size() const {
  return _internal_target_list_size();
}
inline void OnConflictClause::clear_target_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.target_list_.Clear();
}
inline ::pg_query::Node* OnConflictClause::mutable_target_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictClause.target_list)
  return _internal_mutable_target_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* OnConflictClause::mutable_target_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.OnConflictClause.target_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_target_list();
}
inline const ::pg_query::Node& OnConflictClause::target_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.target_list)
  return _internal_target_list().Get(index);
}
inline ::pg_query::Node* OnConflictClause::add_target_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_target_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.OnConflictClause.target_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& OnConflictClause::target_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.OnConflictClause.target_list)
  return _internal_target_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
OnConflictClause::_internal_target_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.target_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
OnConflictClause::_internal_mutable_target_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.target_list_;
}

// .pg_query.Node where_clause = 4 [json_name = "whereClause"];
inline bool OnConflictClause::has_where_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.where_clause_ != nullptr);
  return value;
}
inline void OnConflictClause::clear_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.where_clause_ != nullptr) _impl_.where_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& OnConflictClause::_internal_where_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.where_clause_);
  }
  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OnConflictClause.where_clause)
}
inline ::pg_query::Node* OnConflictClause::release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* OnConflictClause::unsafe_arena_release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.OnConflictClause.where_clause)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* OnConflictClause::_internal_mutable_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.where_clause_;
}
inline ::pg_query::Node* OnConflictClause::mutable_where_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_where_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.OnConflictClause.where_clause)
  return _msg;
}
inline void OnConflictClause::set_allocated_where_clause(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.where_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.OnConflictClause.where_clause)
}

// int32 location = 5 [json_name = "location"];
inline void OnConflictClause::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t OnConflictClause::location() const {
  // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.location)
  return _internal_location();
}
inline void OnConflictClause::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.OnConflictClause.location)
}
inline ::int32_t OnConflictClause::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void OnConflictClause::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CTESearchClause

// repeated .pg_query.Node search_col_list = 1 [json_name = "search_col_list"];
inline int CTESearchClause::_internal_search_col_list_size() const {
  return _internal_search_col_list().size();
}
inline int CTESearchClause::search_col_list_size() const {
  return _internal_search_col_list_size();
}
inline void CTESearchClause::clear_search_col_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.search_col_list_.Clear();
}
inline ::pg_query::Node* CTESearchClause::mutable_search_col_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CTESearchClause.search_col_list)
  return _internal_mutable_search_col_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CTESearchClause::mutable_search_col_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CTESearchClause.search_col_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_search_col_list();
}
inline const ::pg_query::Node& CTESearchClause::search_col_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CTESearchClause.search_col_list)
  return _internal_search_col_list().Get(index);
}
inline ::pg_query::Node* CTESearchClause::add_search_col_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_search_col_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CTESearchClause.search_col_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CTESearchClause::search_col_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CTESearchClause.search_col_list)
  return _internal_search_col_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CTESearchClause::_internal_search_col_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.search_col_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CTESearchClause::_internal_mutable_search_col_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.search_col_list_;
}

// bool search_breadth_first = 2 [json_name = "search_breadth_first"];
inline void CTESearchClause::clear_search_breadth_first() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.search_breadth_first_ = false;
}
inline bool CTESearchClause::search_breadth_first() const {
  // @@protoc_insertion_point(field_get:pg_query.CTESearchClause.search_breadth_first)
  return _internal_search_breadth_first();
}
inline void CTESearchClause::set_search_breadth_first(bool value) {
  _internal_set_search_breadth_first(value);
  // @@protoc_insertion_point(field_set:pg_query.CTESearchClause.search_breadth_first)
}
inline bool CTESearchClause::_internal_search_breadth_first() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.search_breadth_first_;
}
inline void CTESearchClause::_internal_set_search_breadth_first(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.search_breadth_first_ = value;
}

// string search_seq_column = 3 [json_name = "search_seq_column"];
inline void CTESearchClause::clear_search_seq_column() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.search_seq_column_.ClearToEmpty();
}
inline const std::string& CTESearchClause::search_seq_column() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CTESearchClause.search_seq_column)
  return _internal_search_seq_column();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CTESearchClause::set_search_seq_column(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.search_seq_column_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CTESearchClause.search_seq_column)
}
inline std::string* CTESearchClause::mutable_search_seq_column() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_search_seq_column();
  // @@protoc_insertion_point(field_mutable:pg_query.CTESearchClause.search_seq_column)
  return _s;
}
inline const std::string& CTESearchClause::_internal_search_seq_column() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.search_seq_column_.Get();
}
inline void CTESearchClause::_internal_set_search_seq_column(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.search_seq_column_.Set(value, GetArena());
}
inline std::string* CTESearchClause::_internal_mutable_search_seq_column() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.search_seq_column_.Mutable( GetArena());
}
inline std::string* CTESearchClause::release_search_seq_column() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CTESearchClause.search_seq_column)
  return _impl_.search_seq_column_.Release();
}
inline void CTESearchClause::set_allocated_search_seq_column(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.search_seq_column_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.search_seq_column_.IsDefault()) {
          _impl_.search_seq_column_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CTESearchClause.search_seq_column)
}

// int32 location = 4 [json_name = "location"];
inline void CTESearchClause::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t CTESearchClause::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CTESearchClause.location)
  return _internal_location();
}
inline void CTESearchClause::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CTESearchClause.location)
}
inline ::int32_t CTESearchClause::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void CTESearchClause::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CTECycleClause

// repeated .pg_query.Node cycle_col_list = 1 [json_name = "cycle_col_list"];
inline int CTECycleClause::_internal_cycle_col_list_size() const {
  return _internal_cycle_col_list().size();
}
inline int CTECycleClause::cycle_col_list_size() const {
  return _internal_cycle_col_list_size();
}
inline void CTECycleClause::clear_cycle_col_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cycle_col_list_.Clear();
}
inline ::pg_query::Node* CTECycleClause::mutable_cycle_col_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CTECycleClause.cycle_col_list)
  return _internal_mutable_cycle_col_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CTECycleClause::mutable_cycle_col_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CTECycleClause.cycle_col_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_cycle_col_list();
}
inline const ::pg_query::Node& CTECycleClause::cycle_col_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.cycle_col_list)
  return _internal_cycle_col_list().Get(index);
}
inline ::pg_query::Node* CTECycleClause::add_cycle_col_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_cycle_col_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CTECycleClause.cycle_col_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CTECycleClause::cycle_col_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CTECycleClause.cycle_col_list)
  return _internal_cycle_col_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CTECycleClause::_internal_cycle_col_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cycle_col_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CTECycleClause::_internal_mutable_cycle_col_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.cycle_col_list_;
}

// string cycle_mark_column = 2 [json_name = "cycle_mark_column"];
inline void CTECycleClause::clear_cycle_mark_column() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cycle_mark_column_.ClearToEmpty();
}
inline const std::string& CTECycleClause::cycle_mark_column() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.cycle_mark_column)
  return _internal_cycle_mark_column();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CTECycleClause::set_cycle_mark_column(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cycle_mark_column_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CTECycleClause.cycle_mark_column)
}
inline std::string* CTECycleClause::mutable_cycle_mark_column() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_cycle_mark_column();
  // @@protoc_insertion_point(field_mutable:pg_query.CTECycleClause.cycle_mark_column)
  return _s;
}
inline const std::string& CTECycleClause::_internal_cycle_mark_column() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cycle_mark_column_.Get();
}
inline void CTECycleClause::_internal_set_cycle_mark_column(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cycle_mark_column_.Set(value, GetArena());
}
inline std::string* CTECycleClause::_internal_mutable_cycle_mark_column() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.cycle_mark_column_.Mutable( GetArena());
}
inline std::string* CTECycleClause::release_cycle_mark_column() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CTECycleClause.cycle_mark_column)
  return _impl_.cycle_mark_column_.Release();
}
inline void CTECycleClause::set_allocated_cycle_mark_column(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cycle_mark_column_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.cycle_mark_column_.IsDefault()) {
          _impl_.cycle_mark_column_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CTECycleClause.cycle_mark_column)
}

// .pg_query.Node cycle_mark_value = 3 [json_name = "cycle_mark_value"];
inline bool CTECycleClause::has_cycle_mark_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cycle_mark_value_ != nullptr);
  return value;
}
inline void CTECycleClause::clear_cycle_mark_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.cycle_mark_value_ != nullptr) _impl_.cycle_mark_value_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CTECycleClause::_internal_cycle_mark_value() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.cycle_mark_value_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CTECycleClause::cycle_mark_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.cycle_mark_value)
  return _internal_cycle_mark_value();
}
inline void CTECycleClause::unsafe_arena_set_allocated_cycle_mark_value(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cycle_mark_value_);
  }
  _impl_.cycle_mark_value_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CTECycleClause.cycle_mark_value)
}
inline ::pg_query::Node* CTECycleClause::release_cycle_mark_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.cycle_mark_value_;
  _impl_.cycle_mark_value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CTECycleClause::unsafe_arena_release_cycle_mark_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CTECycleClause.cycle_mark_value)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.cycle_mark_value_;
  _impl_.cycle_mark_value_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CTECycleClause::_internal_mutable_cycle_mark_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.cycle_mark_value_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.cycle_mark_value_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.cycle_mark_value_;
}
inline ::pg_query::Node* CTECycleClause::mutable_cycle_mark_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_cycle_mark_value();
  // @@protoc_insertion_point(field_mutable:pg_query.CTECycleClause.cycle_mark_value)
  return _msg;
}
inline void CTECycleClause::set_allocated_cycle_mark_value(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.cycle_mark_value_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.cycle_mark_value_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CTECycleClause.cycle_mark_value)
}

// .pg_query.Node cycle_mark_default = 4 [json_name = "cycle_mark_default"];
inline bool CTECycleClause::has_cycle_mark_default() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cycle_mark_default_ != nullptr);
  return value;
}
inline void CTECycleClause::clear_cycle_mark_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.cycle_mark_default_ != nullptr) _impl_.cycle_mark_default_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& CTECycleClause::_internal_cycle_mark_default() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.cycle_mark_default_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CTECycleClause::cycle_mark_default() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.cycle_mark_default)
  return _internal_cycle_mark_default();
}
inline void CTECycleClause::unsafe_arena_set_allocated_cycle_mark_default(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cycle_mark_default_);
  }
  _impl_.cycle_mark_default_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CTECycleClause.cycle_mark_default)
}
inline ::pg_query::Node* CTECycleClause::release_cycle_mark_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.cycle_mark_default_;
  _impl_.cycle_mark_default_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CTECycleClause::unsafe_arena_release_cycle_mark_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CTECycleClause.cycle_mark_default)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.cycle_mark_default_;
  _impl_.cycle_mark_default_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CTECycleClause::_internal_mutable_cycle_mark_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.cycle_mark_default_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.cycle_mark_default_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.cycle_mark_default_;
}
inline ::pg_query::Node* CTECycleClause::mutable_cycle_mark_default() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_cycle_mark_default();
  // @@protoc_insertion_point(field_mutable:pg_query.CTECycleClause.cycle_mark_default)
  return _msg;
}
inline void CTECycleClause::set_allocated_cycle_mark_default(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.cycle_mark_default_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.cycle_mark_default_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CTECycleClause.cycle_mark_default)
}

// string cycle_path_column = 5 [json_name = "cycle_path_column"];
inline void CTECycleClause::clear_cycle_path_column() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cycle_path_column_.ClearToEmpty();
}
inline const std::string& CTECycleClause::cycle_path_column() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.cycle_path_column)
  return _internal_cycle_path_column();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CTECycleClause::set_cycle_path_column(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cycle_path_column_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CTECycleClause.cycle_path_column)
}
inline std::string* CTECycleClause::mutable_cycle_path_column() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_cycle_path_column();
  // @@protoc_insertion_point(field_mutable:pg_query.CTECycleClause.cycle_path_column)
  return _s;
}
inline const std::string& CTECycleClause::_internal_cycle_path_column() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cycle_path_column_.Get();
}
inline void CTECycleClause::_internal_set_cycle_path_column(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cycle_path_column_.Set(value, GetArena());
}
inline std::string* CTECycleClause::_internal_mutable_cycle_path_column() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.cycle_path_column_.Mutable( GetArena());
}
inline std::string* CTECycleClause::release_cycle_path_column() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CTECycleClause.cycle_path_column)
  return _impl_.cycle_path_column_.Release();
}
inline void CTECycleClause::set_allocated_cycle_path_column(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cycle_path_column_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.cycle_path_column_.IsDefault()) {
          _impl_.cycle_path_column_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CTECycleClause.cycle_path_column)
}

// int32 location = 6 [json_name = "location"];
inline void CTECycleClause::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t CTECycleClause::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.location)
  return _internal_location();
}
inline void CTECycleClause::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CTECycleClause.location)
}
inline ::int32_t CTECycleClause::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void CTECycleClause::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// uint32 cycle_mark_type = 7 [json_name = "cycle_mark_type"];
inline void CTECycleClause::clear_cycle_mark_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cycle_mark_type_ = 0u;
}
inline ::uint32_t CTECycleClause::cycle_mark_type() const {
  // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.cycle_mark_type)
  return _internal_cycle_mark_type();
}
inline void CTECycleClause::set_cycle_mark_type(::uint32_t value) {
  _internal_set_cycle_mark_type(value);
  // @@protoc_insertion_point(field_set:pg_query.CTECycleClause.cycle_mark_type)
}
inline ::uint32_t CTECycleClause::_internal_cycle_mark_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cycle_mark_type_;
}
inline void CTECycleClause::_internal_set_cycle_mark_type(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cycle_mark_type_ = value;
}

// int32 cycle_mark_typmod = 8 [json_name = "cycle_mark_typmod"];
inline void CTECycleClause::clear_cycle_mark_typmod() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cycle_mark_typmod_ = 0;
}
inline ::int32_t CTECycleClause::cycle_mark_typmod() const {
  // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.cycle_mark_typmod)
  return _internal_cycle_mark_typmod();
}
inline void CTECycleClause::set_cycle_mark_typmod(::int32_t value) {
  _internal_set_cycle_mark_typmod(value);
  // @@protoc_insertion_point(field_set:pg_query.CTECycleClause.cycle_mark_typmod)
}
inline ::int32_t CTECycleClause::_internal_cycle_mark_typmod() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cycle_mark_typmod_;
}
inline void CTECycleClause::_internal_set_cycle_mark_typmod(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cycle_mark_typmod_ = value;
}

// uint32 cycle_mark_collation = 9 [json_name = "cycle_mark_collation"];
inline void CTECycleClause::clear_cycle_mark_collation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cycle_mark_collation_ = 0u;
}
inline ::uint32_t CTECycleClause::cycle_mark_collation() const {
  // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.cycle_mark_collation)
  return _internal_cycle_mark_collation();
}
inline void CTECycleClause::set_cycle_mark_collation(::uint32_t value) {
  _internal_set_cycle_mark_collation(value);
  // @@protoc_insertion_point(field_set:pg_query.CTECycleClause.cycle_mark_collation)
}
inline ::uint32_t CTECycleClause::_internal_cycle_mark_collation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cycle_mark_collation_;
}
inline void CTECycleClause::_internal_set_cycle_mark_collation(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cycle_mark_collation_ = value;
}

// uint32 cycle_mark_neop = 10 [json_name = "cycle_mark_neop"];
inline void CTECycleClause::clear_cycle_mark_neop() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cycle_mark_neop_ = 0u;
}
inline ::uint32_t CTECycleClause::cycle_mark_neop() const {
  // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.cycle_mark_neop)
  return _internal_cycle_mark_neop();
}
inline void CTECycleClause::set_cycle_mark_neop(::uint32_t value) {
  _internal_set_cycle_mark_neop(value);
  // @@protoc_insertion_point(field_set:pg_query.CTECycleClause.cycle_mark_neop)
}
inline ::uint32_t CTECycleClause::_internal_cycle_mark_neop() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cycle_mark_neop_;
}
inline void CTECycleClause::_internal_set_cycle_mark_neop(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cycle_mark_neop_ = value;
}

// -------------------------------------------------------------------

// CommonTableExpr

// string ctename = 1 [json_name = "ctename"];
inline void CommonTableExpr::clear_ctename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ctename_.ClearToEmpty();
}
inline const std::string& CommonTableExpr::ctename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctename)
  return _internal_ctename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CommonTableExpr::set_ctename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ctename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.ctename)
}
inline std::string* CommonTableExpr::mutable_ctename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_ctename();
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctename)
  return _s;
}
inline const std::string& CommonTableExpr::_internal_ctename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ctename_.Get();
}
inline void CommonTableExpr::_internal_set_ctename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ctename_.Set(value, GetArena());
}
inline std::string* CommonTableExpr::_internal_mutable_ctename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.ctename_.Mutable( GetArena());
}
inline std::string* CommonTableExpr::release_ctename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CommonTableExpr.ctename)
  return _impl_.ctename_.Release();
}
inline void CommonTableExpr::set_allocated_ctename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ctename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.ctename_.IsDefault()) {
          _impl_.ctename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_aliascolnames().size();
}
inline int CommonTableExpr::aliascolnames_size() const {
  return _internal_aliascolnames_size();
}
inline void CommonTableExpr::clear_aliascolnames() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aliascolnames_.Clear();
}
inline ::pg_query::Node* CommonTableExpr::mutable_aliascolnames(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.aliascolnames)
  return _internal_mutable_aliascolnames()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CommonTableExpr::mutable_aliascolnames()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.aliascolnames)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_aliascolnames();
}
inline const ::pg_query::Node& CommonTableExpr::aliascolnames(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.aliascolnames)
  return _internal_aliascolnames().Get(index);
}
inline ::pg_query::Node* CommonTableExpr::add_aliascolnames() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_aliascolnames()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.aliascolnames)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CommonTableExpr::aliascolnames() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.aliascolnames)
  return _internal_aliascolnames();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CommonTableExpr::_internal_aliascolnames() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aliascolnames_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CommonTableExpr::_internal_mutable_aliascolnames() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.aliascolnames_;
}

// .pg_query.CTEMaterialize ctematerialized = 3 [json_name = "ctematerialized"];
inline void CommonTableExpr::clear_ctematerialized() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ctematerialized_ = 0;
}
inline ::pg_query::CTEMaterialize CommonTableExpr::ctematerialized() const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctematerialized)
  return _internal_ctematerialized();
}
inline void CommonTableExpr::set_ctematerialized(::pg_query::CTEMaterialize value) {
  _internal_set_ctematerialized(value);
  // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.ctematerialized)
}
inline ::pg_query::CTEMaterialize CommonTableExpr::_internal_ctematerialized() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CTEMaterialize>(_impl_.ctematerialized_);
}
inline void CommonTableExpr::_internal_set_ctematerialized(::pg_query::CTEMaterialize value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ctematerialized_ = value;
}

// .pg_query.Node ctequery = 4 [json_name = "ctequery"];
inline bool CommonTableExpr::has_ctequery() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.ctequery_ != nullptr);
  return value;
}
inline void CommonTableExpr::clear_ctequery() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.ctequery_ != nullptr) _impl_.ctequery_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CommonTableExpr::_internal_ctequery() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.ctequery_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CommonTableExpr::ctequery() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctequery)
  return _internal_ctequery();
}
inline void CommonTableExpr::unsafe_arena_set_allocated_ctequery(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.ctequery_);
  }
  _impl_.ctequery_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CommonTableExpr.ctequery)
}
inline ::pg_query::Node* CommonTableExpr::release_ctequery() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.ctequery_;
  _impl_.ctequery_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CommonTableExpr::unsafe_arena_release_ctequery() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CommonTableExpr.ctequery)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.ctequery_;
  _impl_.ctequery_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CommonTableExpr::_internal_mutable_ctequery() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.ctequery_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.ctequery_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.ctequery_;
}
inline ::pg_query::Node* CommonTableExpr::mutable_ctequery() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_ctequery();
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctequery)
  return _msg;
}
inline void CommonTableExpr::set_allocated_ctequery(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.ctequery_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.ctequery_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CommonTableExpr.ctequery)
}

// .pg_query.CTESearchClause search_clause = 5 [json_name = "search_clause"];
inline bool CommonTableExpr::has_search_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.search_clause_ != nullptr);
  return value;
}
inline void CommonTableExpr::clear_search_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.search_clause_ != nullptr) _impl_.search_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::CTESearchClause& CommonTableExpr::_internal_search_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::CTESearchClause* p = _impl_.search_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::CTESearchClause&>(::pg_query::_CTESearchClause_default_instance_);
}
inline const ::pg_query::CTESearchClause& CommonTableExpr::search_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.search_clause)
  return _internal_search_clause();
}
inline void CommonTableExpr::unsafe_arena_set_allocated_search_clause(::pg_query::CTESearchClause* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.search_clause_);
  }
  _impl_.search_clause_ = reinterpret_cast<::pg_query::CTESearchClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CommonTableExpr.search_clause)
}
inline ::pg_query::CTESearchClause* CommonTableExpr::release_search_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::CTESearchClause* released = _impl_.search_clause_;
  _impl_.search_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::CTESearchClause* CommonTableExpr::unsafe_arena_release_search_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CommonTableExpr.search_clause)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::CTESearchClause* temp = _impl_.search_clause_;
  _impl_.search_clause_ = nullptr;
  return temp;
}
inline ::pg_query::CTESearchClause* CommonTableExpr::_internal_mutable_search_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.search_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::CTESearchClause>(GetArena());
    _impl_.search_clause_ = reinterpret_cast<::pg_query::CTESearchClause*>(p);
  }
  return _impl_.search_clause_;
}
inline ::pg_query::CTESearchClause* CommonTableExpr::mutable_search_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CTESearchClause* _msg = _internal_mutable_search_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.search_clause)
  return _msg;
}
inline void CommonTableExpr::set_allocated_search_clause(::pg_query::CTESearchClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::CTESearchClause*>(_impl_.search_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::CTESearchClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.search_clause_ = reinterpret_cast<::pg_query::CTESearchClause*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CommonTableExpr.search_clause)
}

// .pg_query.CTECycleClause cycle_clause = 6 [json_name = "cycle_clause"];
inline bool CommonTableExpr::has_cycle_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cycle_clause_ != nullptr);
  return value;
}
inline void CommonTableExpr::clear_cycle_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.cycle_clause_ != nullptr) _impl_.cycle_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::CTECycleClause& CommonTableExpr::_internal_cycle_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::CTECycleClause* p = _impl_.cycle_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::CTECycleClause&>(::pg_query::_CTECycleClause_default_instance_);
}
inline const ::pg_query::CTECycleClause& CommonTableExpr::cycle_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.cycle_clause)
  return _internal_cycle_clause();
}
inline void CommonTableExpr::unsafe_arena_set_allocated_cycle_clause(::pg_query::CTECycleClause* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cycle_clause_);
  }
  _impl_.cycle_clause_ = reinterpret_cast<::pg_query::CTECycleClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CommonTableExpr.cycle_clause)
}
inline ::pg_query::CTECycleClause* CommonTableExpr::release_cycle_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::CTECycleClause* released = _impl_.cycle_clause_;
  _impl_.cycle_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::CTECycleClause* CommonTableExpr::unsafe_arena_release_cycle_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CommonTableExpr.cycle_clause)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::CTECycleClause* temp = _impl_.cycle_clause_;
  _impl_.cycle_clause_ = nullptr;
  return temp;
}
inline ::pg_query::CTECycleClause* CommonTableExpr::_internal_mutable_cycle_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.cycle_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::CTECycleClause>(GetArena());
    _impl_.cycle_clause_ = reinterpret_cast<::pg_query::CTECycleClause*>(p);
  }
  return _impl_.cycle_clause_;
}
inline ::pg_query::CTECycleClause* CommonTableExpr::mutable_cycle_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CTECycleClause* _msg = _internal_mutable_cycle_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.cycle_clause)
  return _msg;
}
inline void CommonTableExpr::set_allocated_cycle_clause(::pg_query::CTECycleClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::CTECycleClause*>(_impl_.cycle_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::CTECycleClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.cycle_clause_ = reinterpret_cast<::pg_query::CTECycleClause*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CommonTableExpr.cycle_clause)
}

// int32 location = 7 [json_name = "location"];
inline void CommonTableExpr::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t CommonTableExpr::location() const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.location)
  return _internal_location();
}
inline void CommonTableExpr::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.location)
}
inline ::int32_t CommonTableExpr::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void CommonTableExpr::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// bool cterecursive = 8 [json_name = "cterecursive"];
inline void CommonTableExpr::clear_cterecursive() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cterecursive_ = false;
}
inline bool CommonTableExpr::cterecursive() const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.cterecursive)
  return _internal_cterecursive();
}
inline void CommonTableExpr::set_cterecursive(bool value) {
  _internal_set_cterecursive(value);
  // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.cterecursive)
}
inline bool CommonTableExpr::_internal_cterecursive() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cterecursive_;
}
inline void CommonTableExpr::_internal_set_cterecursive(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cterecursive_ = value;
}

// int32 cterefcount = 9 [json_name = "cterefcount"];
inline void CommonTableExpr::clear_cterefcount() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cterefcount_ = 0;
}
inline ::int32_t CommonTableExpr::cterefcount() const {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.cterefcount)
  return _internal_cterefcount();
}
inline void CommonTableExpr::set_cterefcount(::int32_t value) {
  _internal_set_cterefcount(value);
  // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.cterefcount)
}
inline ::int32_t CommonTableExpr::_internal_cterefcount() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cterefcount_;
}
inline void CommonTableExpr::_internal_set_cterefcount(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cterefcount_ = value;
}

// repeated .pg_query.Node ctecolnames = 10 [json_name = "ctecolnames"];
inline int CommonTableExpr::_internal_ctecolnames_size() const {
  return _internal_ctecolnames().size();
}
inline int CommonTableExpr::ctecolnames_size() const {
  return _internal_ctecolnames_size();
}
inline void CommonTableExpr::clear_ctecolnames() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ctecolnames_.Clear();
}
inline ::pg_query::Node* CommonTableExpr::mutable_ctecolnames(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctecolnames)
  return _internal_mutable_ctecolnames()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CommonTableExpr::mutable_ctecolnames()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.ctecolnames)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_ctecolnames();
}
inline const ::pg_query::Node& CommonTableExpr::ctecolnames(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctecolnames)
  return _internal_ctecolnames().Get(index);
}
inline ::pg_query::Node* CommonTableExpr::add_ctecolnames() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_ctecolnames()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.ctecolnames)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CommonTableExpr::ctecolnames() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.ctecolnames)
  return _internal_ctecolnames();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CommonTableExpr::_internal_ctecolnames() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ctecolnames_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CommonTableExpr::_internal_mutable_ctecolnames() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.ctecolnames_;
}

// repeated .pg_query.Node ctecoltypes = 11 [json_name = "ctecoltypes"];
inline int CommonTableExpr::_internal_ctecoltypes_size() const {
  return _internal_ctecoltypes().size();
}
inline int CommonTableExpr::ctecoltypes_size() const {
  return _internal_ctecoltypes_size();
}
inline void CommonTableExpr::clear_ctecoltypes() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ctecoltypes_.Clear();
}
inline ::pg_query::Node* CommonTableExpr::mutable_ctecoltypes(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctecoltypes)
  return _internal_mutable_ctecoltypes()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CommonTableExpr::mutable_ctecoltypes()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.ctecoltypes)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_ctecoltypes();
}
inline const ::pg_query::Node& CommonTableExpr::ctecoltypes(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctecoltypes)
  return _internal_ctecoltypes().Get(index);
}
inline ::pg_query::Node* CommonTableExpr::add_ctecoltypes() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_ctecoltypes()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.ctecoltypes)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CommonTableExpr::ctecoltypes() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.ctecoltypes)
  return _internal_ctecoltypes();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CommonTableExpr::_internal_ctecoltypes() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ctecoltypes_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CommonTableExpr::_internal_mutable_ctecoltypes() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.ctecoltypes_;
}

// repeated .pg_query.Node ctecoltypmods = 12 [json_name = "ctecoltypmods"];
inline int CommonTableExpr::_internal_ctecoltypmods_size() const {
  return _internal_ctecoltypmods().size();
}
inline int CommonTableExpr::ctecoltypmods_size() const {
  return _internal_ctecoltypmods_size();
}
inline void CommonTableExpr::clear_ctecoltypmods() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ctecoltypmods_.Clear();
}
inline ::pg_query::Node* CommonTableExpr::mutable_ctecoltypmods(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctecoltypmods)
  return _internal_mutable_ctecoltypmods()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CommonTableExpr::mutable_ctecoltypmods()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.ctecoltypmods)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_ctecoltypmods();
}
inline const ::pg_query::Node& CommonTableExpr::ctecoltypmods(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctecoltypmods)
  return _internal_ctecoltypmods().Get(index);
}
inline ::pg_query::Node* CommonTableExpr::add_ctecoltypmods() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_ctecoltypmods()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.ctecoltypmods)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CommonTableExpr::ctecoltypmods() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.ctecoltypmods)
  return _internal_ctecoltypmods();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CommonTableExpr::_internal_ctecoltypmods() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ctecoltypmods_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CommonTableExpr::_internal_mutable_ctecoltypmods() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.ctecoltypmods_;
}

// repeated .pg_query.Node ctecolcollations = 13 [json_name = "ctecolcollations"];
inline int CommonTableExpr::_internal_ctecolcollations_size() const {
  return _internal_ctecolcollations().size();
}
inline int CommonTableExpr::ctecolcollations_size() const {
  return _internal_ctecolcollations_size();
}
inline void CommonTableExpr::clear_ctecolcollations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ctecolcollations_.Clear();
}
inline ::pg_query::Node* CommonTableExpr::mutable_ctecolcollations(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctecolcollations)
  return _internal_mutable_ctecolcollations()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CommonTableExpr::mutable_ctecolcollations()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.ctecolcollations)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_ctecolcollations();
}
inline const ::pg_query::Node& CommonTableExpr::ctecolcollations(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctecolcollations)
  return _internal_ctecolcollations().Get(index);
}
inline ::pg_query::Node* CommonTableExpr::add_ctecolcollations() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_ctecolcollations()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.ctecolcollations)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CommonTableExpr::ctecolcollations() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.ctecolcollations)
  return _internal_ctecolcollations();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CommonTableExpr::_internal_ctecolcollations() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ctecolcollations_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CommonTableExpr::_internal_mutable_ctecolcollations() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.ctecolcollations_;
}

// -------------------------------------------------------------------

// MergeWhenClause

// bool matched = 1 [json_name = "matched"];
inline void MergeWhenClause::clear_matched() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.matched_ = false;
}
inline bool MergeWhenClause::matched() const {
  // @@protoc_insertion_point(field_get:pg_query.MergeWhenClause.matched)
  return _internal_matched();
}
inline void MergeWhenClause::set_matched(bool value) {
  _internal_set_matched(value);
  // @@protoc_insertion_point(field_set:pg_query.MergeWhenClause.matched)
}
inline bool MergeWhenClause::_internal_matched() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.matched_;
}
inline void MergeWhenClause::_internal_set_matched(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.matched_ = value;
}

// .pg_query.CmdType command_type = 2 [json_name = "commandType"];
inline void MergeWhenClause::clear_command_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.command_type_ = 0;
}
inline ::pg_query::CmdType MergeWhenClause::command_type() const {
  // @@protoc_insertion_point(field_get:pg_query.MergeWhenClause.command_type)
  return _internal_command_type();
}
inline void MergeWhenClause::set_command_type(::pg_query::CmdType value) {
  _internal_set_command_type(value);
  // @@protoc_insertion_point(field_set:pg_query.MergeWhenClause.command_type)
}
inline ::pg_query::CmdType MergeWhenClause::_internal_command_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CmdType>(_impl_.command_type_);
}
inline void MergeWhenClause::_internal_set_command_type(::pg_query::CmdType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.command_type_ = value;
}

// .pg_query.OverridingKind override = 3 [json_name = "override"];
inline void MergeWhenClause::clear_override() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.override_ = 0;
}
inline ::pg_query::OverridingKind MergeWhenClause::override() const {
  // @@protoc_insertion_point(field_get:pg_query.MergeWhenClause.override)
  return _internal_override();
}
inline void MergeWhenClause::set_override(::pg_query::OverridingKind value) {
  _internal_set_override(value);
  // @@protoc_insertion_point(field_set:pg_query.MergeWhenClause.override)
}
inline ::pg_query::OverridingKind MergeWhenClause::_internal_override() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::OverridingKind>(_impl_.override_);
}
inline void MergeWhenClause::_internal_set_override(::pg_query::OverridingKind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.override_ = value;
}

// .pg_query.Node condition = 4 [json_name = "condition"];
inline bool MergeWhenClause::has_condition() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.condition_ != nullptr);
  return value;
}
inline void MergeWhenClause::clear_condition() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.condition_ != nullptr) _impl_.condition_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& MergeWhenClause::_internal_condition() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.condition_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& MergeWhenClause::condition() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MergeWhenClause.condition)
  return _internal_condition();
}
inline void MergeWhenClause::unsafe_arena_set_allocated_condition(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.condition_);
  }
  _impl_.condition_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MergeWhenClause.condition)
}
inline ::pg_query::Node* MergeWhenClause::release_condition() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.condition_;
  _impl_.condition_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* MergeWhenClause::unsafe_arena_release_condition() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.MergeWhenClause.condition)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.condition_;
  _impl_.condition_ = nullptr;
  return temp;
}
inline ::pg_query::Node* MergeWhenClause::_internal_mutable_condition() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.condition_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.condition_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.condition_;
}
inline ::pg_query::Node* MergeWhenClause::mutable_condition() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_condition();
  // @@protoc_insertion_point(field_mutable:pg_query.MergeWhenClause.condition)
  return _msg;
}
inline void MergeWhenClause::set_allocated_condition(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.condition_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.condition_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.MergeWhenClause.condition)
}

// repeated .pg_query.Node target_list = 5 [json_name = "targetList"];
inline int MergeWhenClause::_internal_target_list_size() const {
  return _internal_target_list().size();
}
inline int MergeWhenClause::target_list_size() const {
  return _internal_target_list_size();
}
inline void MergeWhenClause::clear_target_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.target_list_.Clear();
}
inline ::pg_query::Node* MergeWhenClause::mutable_target_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.MergeWhenClause.target_list)
  return _internal_mutable_target_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* MergeWhenClause::mutable_target_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.MergeWhenClause.target_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_target_list();
}
inline const ::pg_query::Node& MergeWhenClause::target_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MergeWhenClause.target_list)
  return _internal_target_list().Get(index);
}
inline ::pg_query::Node* MergeWhenClause::add_target_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_target_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.MergeWhenClause.target_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& MergeWhenClause::target_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.MergeWhenClause.target_list)
  return _internal_target_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
MergeWhenClause::_internal_target_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.target_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
MergeWhenClause::_internal_mutable_target_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.target_list_;
}

// repeated .pg_query.Node values = 6 [json_name = "values"];
inline int MergeWhenClause::_internal_values_size() const {
  return _internal_values().size();
}
inline int MergeWhenClause::values_size() const {
  return _internal_values_size();
}
inline void MergeWhenClause::clear_values() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.values_.Clear();
}
inline ::pg_query::Node* MergeWhenClause::mutable_values(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.MergeWhenClause.values)
  return _internal_mutable_values()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* MergeWhenClause::mutable_values()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.MergeWhenClause.values)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_values();
}
inline const ::pg_query::Node& MergeWhenClause::values(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MergeWhenClause.values)
  return _internal_values().Get(index);
}
inline ::pg_query::Node* MergeWhenClause::add_values() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_values()->Add();
  // @@protoc_insertion_point(field_add:pg_query.MergeWhenClause.values)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& MergeWhenClause::values() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.MergeWhenClause.values)
  return _internal_values();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
MergeWhenClause::_internal_values() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.values_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
MergeWhenClause::_internal_mutable_values() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.values_;
}

// -------------------------------------------------------------------

// MergeAction

// bool matched = 1 [json_name = "matched"];
inline void MergeAction::clear_matched() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.matched_ = false;
}
inline bool MergeAction::matched() const {
  // @@protoc_insertion_point(field_get:pg_query.MergeAction.matched)
  return _internal_matched();
}
inline void MergeAction::set_matched(bool value) {
  _internal_set_matched(value);
  // @@protoc_insertion_point(field_set:pg_query.MergeAction.matched)
}
inline bool MergeAction::_internal_matched() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.matched_;
}
inline void MergeAction::_internal_set_matched(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.matched_ = value;
}

// .pg_query.CmdType command_type = 2 [json_name = "commandType"];
inline void MergeAction::clear_command_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.command_type_ = 0;
}
inline ::pg_query::CmdType MergeAction::command_type() const {
  // @@protoc_insertion_point(field_get:pg_query.MergeAction.command_type)
  return _internal_command_type();
}
inline void MergeAction::set_command_type(::pg_query::CmdType value) {
  _internal_set_command_type(value);
  // @@protoc_insertion_point(field_set:pg_query.MergeAction.command_type)
}
inline ::pg_query::CmdType MergeAction::_internal_command_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CmdType>(_impl_.command_type_);
}
inline void MergeAction::_internal_set_command_type(::pg_query::CmdType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.command_type_ = value;
}

// .pg_query.OverridingKind override = 3 [json_name = "override"];
inline void MergeAction::clear_override() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.override_ = 0;
}
inline ::pg_query::OverridingKind MergeAction::override() const {
  // @@protoc_insertion_point(field_get:pg_query.MergeAction.override)
  return _internal_override();
}
inline void MergeAction::set_override(::pg_query::OverridingKind value) {
  _internal_set_override(value);
  // @@protoc_insertion_point(field_set:pg_query.MergeAction.override)
}
inline ::pg_query::OverridingKind MergeAction::_internal_override() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::OverridingKind>(_impl_.override_);
}
inline void MergeAction::_internal_set_override(::pg_query::OverridingKind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.override_ = value;
}

// .pg_query.Node qual = 4 [json_name = "qual"];
inline bool MergeAction::has_qual() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.qual_ != nullptr);
  return value;
}
inline void MergeAction::clear_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.qual_ != nullptr) _impl_.qual_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& MergeAction::_internal_qual() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.qual_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& MergeAction::qual() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MergeAction.qual)
  return _internal_qual();
}
inline void MergeAction::unsafe_arena_set_allocated_qual(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.qual_);
  }
  _impl_.qual_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MergeAction.qual)
}
inline ::pg_query::Node* MergeAction::release_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.qual_;
  _impl_.qual_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* MergeAction::unsafe_arena_release_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.MergeAction.qual)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.qual_;
  _impl_.qual_ = nullptr;
  return temp;
}
inline ::pg_query::Node* MergeAction::_internal_mutable_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.qual_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.qual_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.qual_;
}
inline ::pg_query::Node* MergeAction::mutable_qual() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_qual();
  // @@protoc_insertion_point(field_mutable:pg_query.MergeAction.qual)
  return _msg;
}
inline void MergeAction::set_allocated_qual(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.qual_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.qual_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.MergeAction.qual)
}

// repeated .pg_query.Node target_list = 5 [json_name = "targetList"];
inline int MergeAction::_internal_target_list_size() const {
  return _internal_target_list().size();
}
inline int MergeAction::target_list_size() const {
  return _internal_target_list_size();
}
inline void MergeAction::clear_target_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.target_list_.Clear();
}
inline ::pg_query::Node* MergeAction::mutable_target_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.MergeAction.target_list)
  return _internal_mutable_target_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* MergeAction::mutable_target_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.MergeAction.target_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_target_list();
}
inline const ::pg_query::Node& MergeAction::target_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MergeAction.target_list)
  return _internal_target_list().Get(index);
}
inline ::pg_query::Node* MergeAction::add_target_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_target_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.MergeAction.target_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& MergeAction::target_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.MergeAction.target_list)
  return _internal_target_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
MergeAction::_internal_target_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.target_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
MergeAction::_internal_mutable_target_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.target_list_;
}

// repeated .pg_query.Node update_colnos = 6 [json_name = "updateColnos"];
inline int MergeAction::_internal_update_colnos_size() const {
  return _internal_update_colnos().size();
}
inline int MergeAction::update_colnos_size() const {
  return _internal_update_colnos_size();
}
inline void MergeAction::clear_update_colnos() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.update_colnos_.Clear();
}
inline ::pg_query::Node* MergeAction::mutable_update_colnos(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.MergeAction.update_colnos)
  return _internal_mutable_update_colnos()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* MergeAction::mutable_update_colnos()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.MergeAction.update_colnos)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_update_colnos();
}
inline const ::pg_query::Node& MergeAction::update_colnos(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MergeAction.update_colnos)
  return _internal_update_colnos().Get(index);
}
inline ::pg_query::Node* MergeAction::add_update_colnos() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_update_colnos()->Add();
  // @@protoc_insertion_point(field_add:pg_query.MergeAction.update_colnos)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& MergeAction::update_colnos() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.MergeAction.update_colnos)
  return _internal_update_colnos();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
MergeAction::_internal_update_colnos() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.update_colnos_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
MergeAction::_internal_mutable_update_colnos() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.update_colnos_;
}

// -------------------------------------------------------------------

// TriggerTransition

// string name = 1 [json_name = "name"];
inline void TriggerTransition::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& TriggerTransition::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TriggerTransition.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void TriggerTransition::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.TriggerTransition.name)
}
inline std::string* TriggerTransition::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.TriggerTransition.name)
  return _s;
}
inline const std::string& TriggerTransition::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void TriggerTransition::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* TriggerTransition::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* TriggerTransition::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.TriggerTransition.name)
  return _impl_.name_.Release();
}
inline void TriggerTransition::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.TriggerTransition.name)
}

// bool is_new = 2 [json_name = "isNew"];
inline void TriggerTransition::clear_is_new() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_new_ = false;
}
inline bool TriggerTransition::is_new() const {
  // @@protoc_insertion_point(field_get:pg_query.TriggerTransition.is_new)
  return _internal_is_new();
}
inline void TriggerTransition::set_is_new(bool value) {
  _internal_set_is_new(value);
  // @@protoc_insertion_point(field_set:pg_query.TriggerTransition.is_new)
}
inline bool TriggerTransition::_internal_is_new() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_new_;
}
inline void TriggerTransition::_internal_set_is_new(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_new_ = value;
}

// bool is_table = 3 [json_name = "isTable"];
inline void TriggerTransition::clear_is_table() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_table_ = false;
}
inline bool TriggerTransition::is_table() const {
  // @@protoc_insertion_point(field_get:pg_query.TriggerTransition.is_table)
  return _internal_is_table();
}
inline void TriggerTransition::set_is_table(bool value) {
  _internal_set_is_table(value);
  // @@protoc_insertion_point(field_set:pg_query.TriggerTransition.is_table)
}
inline bool TriggerTransition::_internal_is_table() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_table_;
}
inline void TriggerTransition::_internal_set_is_table(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_table_ = value;
}

// -------------------------------------------------------------------

// JsonOutput

// .pg_query.TypeName type_name = 1 [json_name = "typeName"];
inline bool JsonOutput::has_type_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.type_name_ != nullptr);
  return value;
}
inline void JsonOutput::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.type_name_ != nullptr) _impl_.type_name_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::TypeName& JsonOutput::_internal_type_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.type_name_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& JsonOutput::type_name() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonOutput.type_name)
  return _internal_type_name();
}
inline void JsonOutput::unsafe_arena_set_allocated_type_name(::pg_query::TypeName* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_name_);
  }
  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonOutput.type_name)
}
inline ::pg_query::TypeName* JsonOutput::release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* released = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* JsonOutput::unsafe_arena_release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonOutput.type_name)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* temp = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* JsonOutput::_internal_mutable_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.type_name_;
}
inline ::pg_query::TypeName* JsonOutput::mutable_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_type_name();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonOutput.type_name)
  return _msg;
}
inline void JsonOutput::set_allocated_type_name(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.type_name_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonOutput.type_name)
}

// .pg_query.JsonReturning returning = 2 [json_name = "returning"];
inline bool JsonOutput::has_returning() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.returning_ != nullptr);
  return value;
}
inline void JsonOutput::clear_returning() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.returning_ != nullptr) _impl_.returning_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::JsonReturning& JsonOutput::_internal_returning() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonReturning* p = _impl_.returning_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonReturning&>(::pg_query::_JsonReturning_default_instance_);
}
inline const ::pg_query::JsonReturning& JsonOutput::returning() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonOutput.returning)
  return _internal_returning();
}
inline void JsonOutput::unsafe_arena_set_allocated_returning(::pg_query::JsonReturning* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.returning_);
  }
  _impl_.returning_ = reinterpret_cast<::pg_query::JsonReturning*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonOutput.returning)
}
inline ::pg_query::JsonReturning* JsonOutput::release_returning() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::JsonReturning* released = _impl_.returning_;
  _impl_.returning_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonReturning* JsonOutput::unsafe_arena_release_returning() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonOutput.returning)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::JsonReturning* temp = _impl_.returning_;
  _impl_.returning_ = nullptr;
  return temp;
}
inline ::pg_query::JsonReturning* JsonOutput::_internal_mutable_returning() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.returning_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonReturning>(GetArena());
    _impl_.returning_ = reinterpret_cast<::pg_query::JsonReturning*>(p);
  }
  return _impl_.returning_;
}
inline ::pg_query::JsonReturning* JsonOutput::mutable_returning() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonReturning* _msg = _internal_mutable_returning();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonOutput.returning)
  return _msg;
}
inline void JsonOutput::set_allocated_returning(::pg_query::JsonReturning* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonReturning*>(_impl_.returning_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonReturning*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.returning_ = reinterpret_cast<::pg_query::JsonReturning*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonOutput.returning)
}

// -------------------------------------------------------------------

// JsonKeyValue

// .pg_query.Node key = 1 [json_name = "key"];
inline bool JsonKeyValue::has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
  return value;
}
inline void JsonKeyValue::clear_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& JsonKeyValue::_internal_key() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.key_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JsonKeyValue::key() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonKeyValue.key)
  return _internal_key();
}
inline void JsonKeyValue::unsafe_arena_set_allocated_key(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.key_);
  }
  _impl_.key_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonKeyValue.key)
}
inline ::pg_query::Node* JsonKeyValue::release_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.key_;
  _impl_.key_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* JsonKeyValue::unsafe_arena_release_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonKeyValue.key)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.key_;
  _impl_.key_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JsonKeyValue::_internal_mutable_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.key_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.key_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.key_;
}
inline ::pg_query::Node* JsonKeyValue::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonKeyValue.key)
  return _msg;
}
inline void JsonKeyValue::set_allocated_key(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.key_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.key_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonKeyValue.key)
}

// .pg_query.JsonValueExpr value = 2 [json_name = "value"];
inline bool JsonKeyValue::has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr);
  return value;
}
inline void JsonKeyValue::clear_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.value_ != nullptr) _impl_.value_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::JsonValueExpr& JsonKeyValue::_internal_value() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonValueExpr* p = _impl_.value_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonValueExpr&>(::pg_query::_JsonValueExpr_default_instance_);
}
inline const ::pg_query::JsonValueExpr& JsonKeyValue::value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonKeyValue.value)
  return _internal_value();
}
inline void JsonKeyValue::unsafe_arena_set_allocated_value(::pg_query::JsonValueExpr* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.value_);
  }
  _impl_.value_ = reinterpret_cast<::pg_query::JsonValueExpr*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonKeyValue.value)
}
inline ::pg_query::JsonValueExpr* JsonKeyValue::release_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::JsonValueExpr* released = _impl_.value_;
  _impl_.value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonValueExpr* JsonKeyValue::unsafe_arena_release_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonKeyValue.value)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::JsonValueExpr* temp = _impl_.value_;
  _impl_.value_ = nullptr;
  return temp;
}
inline ::pg_query::JsonValueExpr* JsonKeyValue::_internal_mutable_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.value_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonValueExpr>(GetArena());
    _impl_.value_ = reinterpret_cast<::pg_query::JsonValueExpr*>(p);
  }
  return _impl_.value_;
}
inline ::pg_query::JsonValueExpr* JsonKeyValue::mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonValueExpr* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonKeyValue.value)
  return _msg;
}
inline void JsonKeyValue::set_allocated_value(::pg_query::JsonValueExpr* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonValueExpr*>(_impl_.value_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonValueExpr*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.value_ = reinterpret_cast<::pg_query::JsonValueExpr*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonKeyValue.value)
}

// -------------------------------------------------------------------

// JsonObjectConstructor

// repeated .pg_query.Node exprs = 1 [json_name = "exprs"];
inline int JsonObjectConstructor::_internal_exprs_size() const {
  return _internal_exprs().size();
}
inline int JsonObjectConstructor::exprs_size() const {
  return _internal_exprs_size();
}
inline void JsonObjectConstructor::clear_exprs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.exprs_.Clear();
}
inline ::pg_query::Node* JsonObjectConstructor::mutable_exprs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.JsonObjectConstructor.exprs)
  return _internal_mutable_exprs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* JsonObjectConstructor::mutable_exprs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.JsonObjectConstructor.exprs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_exprs();
}
inline const ::pg_query::Node& JsonObjectConstructor::exprs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonObjectConstructor.exprs)
  return _internal_exprs().Get(index);
}
inline ::pg_query::Node* JsonObjectConstructor::add_exprs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_exprs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.JsonObjectConstructor.exprs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& JsonObjectConstructor::exprs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.JsonObjectConstructor.exprs)
  return _internal_exprs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
JsonObjectConstructor::_internal_exprs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.exprs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
JsonObjectConstructor::_internal_mutable_exprs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.exprs_;
}

// .pg_query.JsonOutput output = 2 [json_name = "output"];
inline bool JsonObjectConstructor::has_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.output_ != nullptr);
  return value;
}
inline void JsonObjectConstructor::clear_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.output_ != nullptr) _impl_.output_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::JsonOutput& JsonObjectConstructor::_internal_output() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonOutput* p = _impl_.output_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonOutput&>(::pg_query::_JsonOutput_default_instance_);
}
inline const ::pg_query::JsonOutput& JsonObjectConstructor::output() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonObjectConstructor.output)
  return _internal_output();
}
inline void JsonObjectConstructor::unsafe_arena_set_allocated_output(::pg_query::JsonOutput* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.output_);
  }
  _impl_.output_ = reinterpret_cast<::pg_query::JsonOutput*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonObjectConstructor.output)
}
inline ::pg_query::JsonOutput* JsonObjectConstructor::release_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::JsonOutput* released = _impl_.output_;
  _impl_.output_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonOutput* JsonObjectConstructor::unsafe_arena_release_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonObjectConstructor.output)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::JsonOutput* temp = _impl_.output_;
  _impl_.output_ = nullptr;
  return temp;
}
inline ::pg_query::JsonOutput* JsonObjectConstructor::_internal_mutable_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.output_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonOutput>(GetArena());
    _impl_.output_ = reinterpret_cast<::pg_query::JsonOutput*>(p);
  }
  return _impl_.output_;
}
inline ::pg_query::JsonOutput* JsonObjectConstructor::mutable_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonOutput* _msg = _internal_mutable_output();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonObjectConstructor.output)
  return _msg;
}
inline void JsonObjectConstructor::set_allocated_output(::pg_query::JsonOutput* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonOutput*>(_impl_.output_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonOutput*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.output_ = reinterpret_cast<::pg_query::JsonOutput*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonObjectConstructor.output)
}

// bool absent_on_null = 3 [json_name = "absent_on_null"];
inline void JsonObjectConstructor::clear_absent_on_null() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.absent_on_null_ = false;
}
inline bool JsonObjectConstructor::absent_on_null() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonObjectConstructor.absent_on_null)
  return _internal_absent_on_null();
}
inline void JsonObjectConstructor::set_absent_on_null(bool value) {
  _internal_set_absent_on_null(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonObjectConstructor.absent_on_null)
}
inline bool JsonObjectConstructor::_internal_absent_on_null() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.absent_on_null_;
}
inline void JsonObjectConstructor::_internal_set_absent_on_null(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.absent_on_null_ = value;
}

// bool unique = 4 [json_name = "unique"];
inline void JsonObjectConstructor::clear_unique() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.unique_ = false;
}
inline bool JsonObjectConstructor::unique() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonObjectConstructor.unique)
  return _internal_unique();
}
inline void JsonObjectConstructor::set_unique(bool value) {
  _internal_set_unique(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonObjectConstructor.unique)
}
inline bool JsonObjectConstructor::_internal_unique() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.unique_;
}
inline void JsonObjectConstructor::_internal_set_unique(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.unique_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void JsonObjectConstructor::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t JsonObjectConstructor::location() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonObjectConstructor.location)
  return _internal_location();
}
inline void JsonObjectConstructor::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonObjectConstructor.location)
}
inline ::int32_t JsonObjectConstructor::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void JsonObjectConstructor::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// JsonArrayConstructor

// repeated .pg_query.Node exprs = 1 [json_name = "exprs"];
inline int JsonArrayConstructor::_internal_exprs_size() const {
  return _internal_exprs().size();
}
inline int JsonArrayConstructor::exprs_size() const {
  return _internal_exprs_size();
}
inline void JsonArrayConstructor::clear_exprs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.exprs_.Clear();
}
inline ::pg_query::Node* JsonArrayConstructor::mutable_exprs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.JsonArrayConstructor.exprs)
  return _internal_mutable_exprs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* JsonArrayConstructor::mutable_exprs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.JsonArrayConstructor.exprs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_exprs();
}
inline const ::pg_query::Node& JsonArrayConstructor::exprs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonArrayConstructor.exprs)
  return _internal_exprs().Get(index);
}
inline ::pg_query::Node* JsonArrayConstructor::add_exprs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_exprs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.JsonArrayConstructor.exprs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& JsonArrayConstructor::exprs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.JsonArrayConstructor.exprs)
  return _internal_exprs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
JsonArrayConstructor::_internal_exprs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.exprs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
JsonArrayConstructor::_internal_mutable_exprs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.exprs_;
}

// .pg_query.JsonOutput output = 2 [json_name = "output"];
inline bool JsonArrayConstructor::has_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.output_ != nullptr);
  return value;
}
inline void JsonArrayConstructor::clear_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.output_ != nullptr) _impl_.output_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::JsonOutput& JsonArrayConstructor::_internal_output() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonOutput* p = _impl_.output_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonOutput&>(::pg_query::_JsonOutput_default_instance_);
}
inline const ::pg_query::JsonOutput& JsonArrayConstructor::output() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonArrayConstructor.output)
  return _internal_output();
}
inline void JsonArrayConstructor::unsafe_arena_set_allocated_output(::pg_query::JsonOutput* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.output_);
  }
  _impl_.output_ = reinterpret_cast<::pg_query::JsonOutput*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonArrayConstructor.output)
}
inline ::pg_query::JsonOutput* JsonArrayConstructor::release_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::JsonOutput* released = _impl_.output_;
  _impl_.output_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonOutput* JsonArrayConstructor::unsafe_arena_release_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonArrayConstructor.output)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::JsonOutput* temp = _impl_.output_;
  _impl_.output_ = nullptr;
  return temp;
}
inline ::pg_query::JsonOutput* JsonArrayConstructor::_internal_mutable_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.output_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonOutput>(GetArena());
    _impl_.output_ = reinterpret_cast<::pg_query::JsonOutput*>(p);
  }
  return _impl_.output_;
}
inline ::pg_query::JsonOutput* JsonArrayConstructor::mutable_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonOutput* _msg = _internal_mutable_output();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonArrayConstructor.output)
  return _msg;
}
inline void JsonArrayConstructor::set_allocated_output(::pg_query::JsonOutput* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonOutput*>(_impl_.output_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonOutput*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.output_ = reinterpret_cast<::pg_query::JsonOutput*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonArrayConstructor.output)
}

// bool absent_on_null = 3 [json_name = "absent_on_null"];
inline void JsonArrayConstructor::clear_absent_on_null() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.absent_on_null_ = false;
}
inline bool JsonArrayConstructor::absent_on_null() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonArrayConstructor.absent_on_null)
  return _internal_absent_on_null();
}
inline void JsonArrayConstructor::set_absent_on_null(bool value) {
  _internal_set_absent_on_null(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonArrayConstructor.absent_on_null)
}
inline bool JsonArrayConstructor::_internal_absent_on_null() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.absent_on_null_;
}
inline void JsonArrayConstructor::_internal_set_absent_on_null(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.absent_on_null_ = value;
}

// int32 location = 4 [json_name = "location"];
inline void JsonArrayConstructor::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t JsonArrayConstructor::location() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonArrayConstructor.location)
  return _internal_location();
}
inline void JsonArrayConstructor::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonArrayConstructor.location)
}
inline ::int32_t JsonArrayConstructor::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void JsonArrayConstructor::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// JsonArrayQueryConstructor

// .pg_query.Node query = 1 [json_name = "query"];
inline bool JsonArrayQueryConstructor::has_query() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.query_ != nullptr);
  return value;
}
inline void JsonArrayQueryConstructor::clear_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.query_ != nullptr) _impl_.query_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& JsonArrayQueryConstructor::_internal_query() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JsonArrayQueryConstructor::query() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonArrayQueryConstructor.query)
  return _internal_query();
}
inline void JsonArrayQueryConstructor::unsafe_arena_set_allocated_query(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.query_);
  }
  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonArrayQueryConstructor.query)
}
inline ::pg_query::Node* JsonArrayQueryConstructor::release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.query_;
  _impl_.query_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* JsonArrayQueryConstructor::unsafe_arena_release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonArrayQueryConstructor.query)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.query_;
  _impl_.query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JsonArrayQueryConstructor::_internal_mutable_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.query_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.query_;
}
inline ::pg_query::Node* JsonArrayQueryConstructor::mutable_query() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_query();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonArrayQueryConstructor.query)
  return _msg;
}
inline void JsonArrayQueryConstructor::set_allocated_query(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.query_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonArrayQueryConstructor.query)
}

// .pg_query.JsonOutput output = 2 [json_name = "output"];
inline bool JsonArrayQueryConstructor::has_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.output_ != nullptr);
  return value;
}
inline void JsonArrayQueryConstructor::clear_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.output_ != nullptr) _impl_.output_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::JsonOutput& JsonArrayQueryConstructor::_internal_output() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonOutput* p = _impl_.output_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonOutput&>(::pg_query::_JsonOutput_default_instance_);
}
inline const ::pg_query::JsonOutput& JsonArrayQueryConstructor::output() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonArrayQueryConstructor.output)
  return _internal_output();
}
inline void JsonArrayQueryConstructor::unsafe_arena_set_allocated_output(::pg_query::JsonOutput* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.output_);
  }
  _impl_.output_ = reinterpret_cast<::pg_query::JsonOutput*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonArrayQueryConstructor.output)
}
inline ::pg_query::JsonOutput* JsonArrayQueryConstructor::release_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::JsonOutput* released = _impl_.output_;
  _impl_.output_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonOutput* JsonArrayQueryConstructor::unsafe_arena_release_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonArrayQueryConstructor.output)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::JsonOutput* temp = _impl_.output_;
  _impl_.output_ = nullptr;
  return temp;
}
inline ::pg_query::JsonOutput* JsonArrayQueryConstructor::_internal_mutable_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.output_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonOutput>(GetArena());
    _impl_.output_ = reinterpret_cast<::pg_query::JsonOutput*>(p);
  }
  return _impl_.output_;
}
inline ::pg_query::JsonOutput* JsonArrayQueryConstructor::mutable_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonOutput* _msg = _internal_mutable_output();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonArrayQueryConstructor.output)
  return _msg;
}
inline void JsonArrayQueryConstructor::set_allocated_output(::pg_query::JsonOutput* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonOutput*>(_impl_.output_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonOutput*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.output_ = reinterpret_cast<::pg_query::JsonOutput*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonArrayQueryConstructor.output)
}

// .pg_query.JsonFormat format = 3 [json_name = "format"];
inline bool JsonArrayQueryConstructor::has_format() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.format_ != nullptr);
  return value;
}
inline void JsonArrayQueryConstructor::clear_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.format_ != nullptr) _impl_.format_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::JsonFormat& JsonArrayQueryConstructor::_internal_format() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonFormat* p = _impl_.format_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonFormat&>(::pg_query::_JsonFormat_default_instance_);
}
inline const ::pg_query::JsonFormat& JsonArrayQueryConstructor::format() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonArrayQueryConstructor.format)
  return _internal_format();
}
inline void JsonArrayQueryConstructor::unsafe_arena_set_allocated_format(::pg_query::JsonFormat* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.format_);
  }
  _impl_.format_ = reinterpret_cast<::pg_query::JsonFormat*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonArrayQueryConstructor.format)
}
inline ::pg_query::JsonFormat* JsonArrayQueryConstructor::release_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::JsonFormat* released = _impl_.format_;
  _impl_.format_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonFormat* JsonArrayQueryConstructor::unsafe_arena_release_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonArrayQueryConstructor.format)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::JsonFormat* temp = _impl_.format_;
  _impl_.format_ = nullptr;
  return temp;
}
inline ::pg_query::JsonFormat* JsonArrayQueryConstructor::_internal_mutable_format() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.format_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonFormat>(GetArena());
    _impl_.format_ = reinterpret_cast<::pg_query::JsonFormat*>(p);
  }
  return _impl_.format_;
}
inline ::pg_query::JsonFormat* JsonArrayQueryConstructor::mutable_format() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonFormat* _msg = _internal_mutable_format();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonArrayQueryConstructor.format)
  return _msg;
}
inline void JsonArrayQueryConstructor::set_allocated_format(::pg_query::JsonFormat* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonFormat*>(_impl_.format_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonFormat*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.format_ = reinterpret_cast<::pg_query::JsonFormat*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonArrayQueryConstructor.format)
}

// bool absent_on_null = 4 [json_name = "absent_on_null"];
inline void JsonArrayQueryConstructor::clear_absent_on_null() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.absent_on_null_ = false;
}
inline bool JsonArrayQueryConstructor::absent_on_null() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonArrayQueryConstructor.absent_on_null)
  return _internal_absent_on_null();
}
inline void JsonArrayQueryConstructor::set_absent_on_null(bool value) {
  _internal_set_absent_on_null(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonArrayQueryConstructor.absent_on_null)
}
inline bool JsonArrayQueryConstructor::_internal_absent_on_null() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.absent_on_null_;
}
inline void JsonArrayQueryConstructor::_internal_set_absent_on_null(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.absent_on_null_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void JsonArrayQueryConstructor::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t JsonArrayQueryConstructor::location() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonArrayQueryConstructor.location)
  return _internal_location();
}
inline void JsonArrayQueryConstructor::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonArrayQueryConstructor.location)
}
inline ::int32_t JsonArrayQueryConstructor::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void JsonArrayQueryConstructor::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// JsonAggConstructor

// .pg_query.JsonOutput output = 1 [json_name = "output"];
inline bool JsonAggConstructor::has_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.output_ != nullptr);
  return value;
}
inline void JsonAggConstructor::clear_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.output_ != nullptr) _impl_.output_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::JsonOutput& JsonAggConstructor::_internal_output() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonOutput* p = _impl_.output_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonOutput&>(::pg_query::_JsonOutput_default_instance_);
}
inline const ::pg_query::JsonOutput& JsonAggConstructor::output() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonAggConstructor.output)
  return _internal_output();
}
inline void JsonAggConstructor::unsafe_arena_set_allocated_output(::pg_query::JsonOutput* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.output_);
  }
  _impl_.output_ = reinterpret_cast<::pg_query::JsonOutput*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonAggConstructor.output)
}
inline ::pg_query::JsonOutput* JsonAggConstructor::release_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::JsonOutput* released = _impl_.output_;
  _impl_.output_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonOutput* JsonAggConstructor::unsafe_arena_release_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonAggConstructor.output)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::JsonOutput* temp = _impl_.output_;
  _impl_.output_ = nullptr;
  return temp;
}
inline ::pg_query::JsonOutput* JsonAggConstructor::_internal_mutable_output() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.output_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonOutput>(GetArena());
    _impl_.output_ = reinterpret_cast<::pg_query::JsonOutput*>(p);
  }
  return _impl_.output_;
}
inline ::pg_query::JsonOutput* JsonAggConstructor::mutable_output() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonOutput* _msg = _internal_mutable_output();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonAggConstructor.output)
  return _msg;
}
inline void JsonAggConstructor::set_allocated_output(::pg_query::JsonOutput* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonOutput*>(_impl_.output_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonOutput*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.output_ = reinterpret_cast<::pg_query::JsonOutput*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonAggConstructor.output)
}

// .pg_query.Node agg_filter = 2 [json_name = "agg_filter"];
inline bool JsonAggConstructor::has_agg_filter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.agg_filter_ != nullptr);
  return value;
}
inline void JsonAggConstructor::clear_agg_filter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.agg_filter_ != nullptr) _impl_.agg_filter_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& JsonAggConstructor::_internal_agg_filter() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.agg_filter_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& JsonAggConstructor::agg_filter() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonAggConstructor.agg_filter)
  return _internal_agg_filter();
}
inline void JsonAggConstructor::unsafe_arena_set_allocated_agg_filter(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.agg_filter_);
  }
  _impl_.agg_filter_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonAggConstructor.agg_filter)
}
inline ::pg_query::Node* JsonAggConstructor::release_agg_filter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.agg_filter_;
  _impl_.agg_filter_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* JsonAggConstructor::unsafe_arena_release_agg_filter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonAggConstructor.agg_filter)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.agg_filter_;
  _impl_.agg_filter_ = nullptr;
  return temp;
}
inline ::pg_query::Node* JsonAggConstructor::_internal_mutable_agg_filter() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.agg_filter_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.agg_filter_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.agg_filter_;
}
inline ::pg_query::Node* JsonAggConstructor::mutable_agg_filter() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_agg_filter();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonAggConstructor.agg_filter)
  return _msg;
}
inline void JsonAggConstructor::set_allocated_agg_filter(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.agg_filter_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.agg_filter_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonAggConstructor.agg_filter)
}

// repeated .pg_query.Node agg_order = 3 [json_name = "agg_order"];
inline int JsonAggConstructor::_internal_agg_order_size() const {
  return _internal_agg_order().size();
}
inline int JsonAggConstructor::agg_order_size() const {
  return _internal_agg_order_size();
}
inline void JsonAggConstructor::clear_agg_order() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.agg_order_.Clear();
}
inline ::pg_query::Node* JsonAggConstructor::mutable_agg_order(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.JsonAggConstructor.agg_order)
  return _internal_mutable_agg_order()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* JsonAggConstructor::mutable_agg_order()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.JsonAggConstructor.agg_order)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_agg_order();
}
inline const ::pg_query::Node& JsonAggConstructor::agg_order(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonAggConstructor.agg_order)
  return _internal_agg_order().Get(index);
}
inline ::pg_query::Node* JsonAggConstructor::add_agg_order() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_agg_order()->Add();
  // @@protoc_insertion_point(field_add:pg_query.JsonAggConstructor.agg_order)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& JsonAggConstructor::agg_order() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.JsonAggConstructor.agg_order)
  return _internal_agg_order();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
JsonAggConstructor::_internal_agg_order() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.agg_order_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
JsonAggConstructor::_internal_mutable_agg_order() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.agg_order_;
}

// .pg_query.WindowDef over = 4 [json_name = "over"];
inline bool JsonAggConstructor::has_over() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.over_ != nullptr);
  return value;
}
inline void JsonAggConstructor::clear_over() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.over_ != nullptr) _impl_.over_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::WindowDef& JsonAggConstructor::_internal_over() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::WindowDef* p = _impl_.over_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::WindowDef&>(::pg_query::_WindowDef_default_instance_);
}
inline const ::pg_query::WindowDef& JsonAggConstructor::over() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonAggConstructor.over)
  return _internal_over();
}
inline void JsonAggConstructor::unsafe_arena_set_allocated_over(::pg_query::WindowDef* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.over_);
  }
  _impl_.over_ = reinterpret_cast<::pg_query::WindowDef*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonAggConstructor.over)
}
inline ::pg_query::WindowDef* JsonAggConstructor::release_over() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::WindowDef* released = _impl_.over_;
  _impl_.over_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::WindowDef* JsonAggConstructor::unsafe_arena_release_over() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonAggConstructor.over)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::WindowDef* temp = _impl_.over_;
  _impl_.over_ = nullptr;
  return temp;
}
inline ::pg_query::WindowDef* JsonAggConstructor::_internal_mutable_over() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.over_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::WindowDef>(GetArena());
    _impl_.over_ = reinterpret_cast<::pg_query::WindowDef*>(p);
  }
  return _impl_.over_;
}
inline ::pg_query::WindowDef* JsonAggConstructor::mutable_over() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::WindowDef* _msg = _internal_mutable_over();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonAggConstructor.over)
  return _msg;
}
inline void JsonAggConstructor::set_allocated_over(::pg_query::WindowDef* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::WindowDef*>(_impl_.over_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::WindowDef*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.over_ = reinterpret_cast<::pg_query::WindowDef*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonAggConstructor.over)
}

// int32 location = 5 [json_name = "location"];
inline void JsonAggConstructor::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t JsonAggConstructor::location() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonAggConstructor.location)
  return _internal_location();
}
inline void JsonAggConstructor::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonAggConstructor.location)
}
inline ::int32_t JsonAggConstructor::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void JsonAggConstructor::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// JsonObjectAgg

// .pg_query.JsonAggConstructor constructor = 1 [json_name = "constructor"];
inline bool JsonObjectAgg::has_constructor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.constructor_ != nullptr);
  return value;
}
inline void JsonObjectAgg::clear_constructor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.constructor_ != nullptr) _impl_.constructor_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::JsonAggConstructor& JsonObjectAgg::_internal_constructor() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonAggConstructor* p = _impl_.constructor_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonAggConstructor&>(::pg_query::_JsonAggConstructor_default_instance_);
}
inline const ::pg_query::JsonAggConstructor& JsonObjectAgg::constructor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonObjectAgg.constructor)
  return _internal_constructor();
}
inline void JsonObjectAgg::unsafe_arena_set_allocated_constructor(::pg_query::JsonAggConstructor* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.constructor_);
  }
  _impl_.constructor_ = reinterpret_cast<::pg_query::JsonAggConstructor*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonObjectAgg.constructor)
}
inline ::pg_query::JsonAggConstructor* JsonObjectAgg::release_constructor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::JsonAggConstructor* released = _impl_.constructor_;
  _impl_.constructor_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonAggConstructor* JsonObjectAgg::unsafe_arena_release_constructor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonObjectAgg.constructor)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::JsonAggConstructor* temp = _impl_.constructor_;
  _impl_.constructor_ = nullptr;
  return temp;
}
inline ::pg_query::JsonAggConstructor* JsonObjectAgg::_internal_mutable_constructor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.constructor_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonAggConstructor>(GetArena());
    _impl_.constructor_ = reinterpret_cast<::pg_query::JsonAggConstructor*>(p);
  }
  return _impl_.constructor_;
}
inline ::pg_query::JsonAggConstructor* JsonObjectAgg::mutable_constructor() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonAggConstructor* _msg = _internal_mutable_constructor();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonObjectAgg.constructor)
  return _msg;
}
inline void JsonObjectAgg::set_allocated_constructor(::pg_query::JsonAggConstructor* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonAggConstructor*>(_impl_.constructor_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonAggConstructor*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.constructor_ = reinterpret_cast<::pg_query::JsonAggConstructor*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonObjectAgg.constructor)
}

// .pg_query.JsonKeyValue arg = 2 [json_name = "arg"];
inline bool JsonObjectAgg::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void JsonObjectAgg::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::JsonKeyValue& JsonObjectAgg::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonKeyValue* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonKeyValue&>(::pg_query::_JsonKeyValue_default_instance_);
}
inline const ::pg_query::JsonKeyValue& JsonObjectAgg::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonObjectAgg.arg)
  return _internal_arg();
}
inline void JsonObjectAgg::unsafe_arena_set_allocated_arg(::pg_query::JsonKeyValue* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::JsonKeyValue*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonObjectAgg.arg)
}
inline ::pg_query::JsonKeyValue* JsonObjectAgg::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::JsonKeyValue* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonKeyValue* JsonObjectAgg::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonObjectAgg.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::JsonKeyValue* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::JsonKeyValue* JsonObjectAgg::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonKeyValue>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::JsonKeyValue*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::JsonKeyValue* JsonObjectAgg::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonKeyValue* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonObjectAgg.arg)
  return _msg;
}
inline void JsonObjectAgg::set_allocated_arg(::pg_query::JsonKeyValue* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonKeyValue*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonKeyValue*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::JsonKeyValue*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonObjectAgg.arg)
}

// bool absent_on_null = 3 [json_name = "absent_on_null"];
inline void JsonObjectAgg::clear_absent_on_null() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.absent_on_null_ = false;
}
inline bool JsonObjectAgg::absent_on_null() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonObjectAgg.absent_on_null)
  return _internal_absent_on_null();
}
inline void JsonObjectAgg::set_absent_on_null(bool value) {
  _internal_set_absent_on_null(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonObjectAgg.absent_on_null)
}
inline bool JsonObjectAgg::_internal_absent_on_null() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.absent_on_null_;
}
inline void JsonObjectAgg::_internal_set_absent_on_null(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.absent_on_null_ = value;
}

// bool unique = 4 [json_name = "unique"];
inline void JsonObjectAgg::clear_unique() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.unique_ = false;
}
inline bool JsonObjectAgg::unique() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonObjectAgg.unique)
  return _internal_unique();
}
inline void JsonObjectAgg::set_unique(bool value) {
  _internal_set_unique(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonObjectAgg.unique)
}
inline bool JsonObjectAgg::_internal_unique() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.unique_;
}
inline void JsonObjectAgg::_internal_set_unique(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.unique_ = value;
}

// -------------------------------------------------------------------

// JsonArrayAgg

// .pg_query.JsonAggConstructor constructor = 1 [json_name = "constructor"];
inline bool JsonArrayAgg::has_constructor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.constructor_ != nullptr);
  return value;
}
inline void JsonArrayAgg::clear_constructor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.constructor_ != nullptr) _impl_.constructor_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::JsonAggConstructor& JsonArrayAgg::_internal_constructor() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonAggConstructor* p = _impl_.constructor_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonAggConstructor&>(::pg_query::_JsonAggConstructor_default_instance_);
}
inline const ::pg_query::JsonAggConstructor& JsonArrayAgg::constructor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonArrayAgg.constructor)
  return _internal_constructor();
}
inline void JsonArrayAgg::unsafe_arena_set_allocated_constructor(::pg_query::JsonAggConstructor* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.constructor_);
  }
  _impl_.constructor_ = reinterpret_cast<::pg_query::JsonAggConstructor*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonArrayAgg.constructor)
}
inline ::pg_query::JsonAggConstructor* JsonArrayAgg::release_constructor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::JsonAggConstructor* released = _impl_.constructor_;
  _impl_.constructor_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonAggConstructor* JsonArrayAgg::unsafe_arena_release_constructor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonArrayAgg.constructor)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::JsonAggConstructor* temp = _impl_.constructor_;
  _impl_.constructor_ = nullptr;
  return temp;
}
inline ::pg_query::JsonAggConstructor* JsonArrayAgg::_internal_mutable_constructor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.constructor_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonAggConstructor>(GetArena());
    _impl_.constructor_ = reinterpret_cast<::pg_query::JsonAggConstructor*>(p);
  }
  return _impl_.constructor_;
}
inline ::pg_query::JsonAggConstructor* JsonArrayAgg::mutable_constructor() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonAggConstructor* _msg = _internal_mutable_constructor();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonArrayAgg.constructor)
  return _msg;
}
inline void JsonArrayAgg::set_allocated_constructor(::pg_query::JsonAggConstructor* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonAggConstructor*>(_impl_.constructor_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonAggConstructor*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.constructor_ = reinterpret_cast<::pg_query::JsonAggConstructor*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonArrayAgg.constructor)
}

// .pg_query.JsonValueExpr arg = 2 [json_name = "arg"];
inline bool JsonArrayAgg::has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_ != nullptr);
  return value;
}
inline void JsonArrayAgg::clear_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_ != nullptr) _impl_.arg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::JsonValueExpr& JsonArrayAgg::_internal_arg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::JsonValueExpr* p = _impl_.arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::JsonValueExpr&>(::pg_query::_JsonValueExpr_default_instance_);
}
inline const ::pg_query::JsonValueExpr& JsonArrayAgg::arg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.JsonArrayAgg.arg)
  return _internal_arg();
}
inline void JsonArrayAgg::unsafe_arena_set_allocated_arg(::pg_query::JsonValueExpr* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_);
  }
  _impl_.arg_ = reinterpret_cast<::pg_query::JsonValueExpr*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JsonArrayAgg.arg)
}
inline ::pg_query::JsonValueExpr* JsonArrayAgg::release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::JsonValueExpr* released = _impl_.arg_;
  _impl_.arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::JsonValueExpr* JsonArrayAgg::unsafe_arena_release_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.JsonArrayAgg.arg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::JsonValueExpr* temp = _impl_.arg_;
  _impl_.arg_ = nullptr;
  return temp;
}
inline ::pg_query::JsonValueExpr* JsonArrayAgg::_internal_mutable_arg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::JsonValueExpr>(GetArena());
    _impl_.arg_ = reinterpret_cast<::pg_query::JsonValueExpr*>(p);
  }
  return _impl_.arg_;
}
inline ::pg_query::JsonValueExpr* JsonArrayAgg::mutable_arg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::JsonValueExpr* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:pg_query.JsonArrayAgg.arg)
  return _msg;
}
inline void JsonArrayAgg::set_allocated_arg(::pg_query::JsonValueExpr* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::JsonValueExpr*>(_impl_.arg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::JsonValueExpr*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.arg_ = reinterpret_cast<::pg_query::JsonValueExpr*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.JsonArrayAgg.arg)
}

// bool absent_on_null = 3 [json_name = "absent_on_null"];
inline void JsonArrayAgg::clear_absent_on_null() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.absent_on_null_ = false;
}
inline bool JsonArrayAgg::absent_on_null() const {
  // @@protoc_insertion_point(field_get:pg_query.JsonArrayAgg.absent_on_null)
  return _internal_absent_on_null();
}
inline void JsonArrayAgg::set_absent_on_null(bool value) {
  _internal_set_absent_on_null(value);
  // @@protoc_insertion_point(field_set:pg_query.JsonArrayAgg.absent_on_null)
}
inline bool JsonArrayAgg::_internal_absent_on_null() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.absent_on_null_;
}
inline void JsonArrayAgg::_internal_set_absent_on_null(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.absent_on_null_ = value;
}

// -------------------------------------------------------------------

// RawStmt

// .pg_query.Node stmt = 1 [json_name = "stmt"];
inline bool RawStmt::has_stmt() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.stmt_ != nullptr);
  return value;
}
inline void RawStmt::clear_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.stmt_ != nullptr) _impl_.stmt_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& RawStmt::_internal_stmt() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.stmt_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RawStmt::stmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RawStmt.stmt)
  return _internal_stmt();
}
inline void RawStmt::unsafe_arena_set_allocated_stmt(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.stmt_);
  }
  _impl_.stmt_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RawStmt.stmt)
}
inline ::pg_query::Node* RawStmt::release_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.stmt_;
  _impl_.stmt_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RawStmt::unsafe_arena_release_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RawStmt.stmt)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.stmt_;
  _impl_.stmt_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RawStmt::_internal_mutable_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.stmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.stmt_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.stmt_;
}
inline ::pg_query::Node* RawStmt::mutable_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.RawStmt.stmt)
  return _msg;
}
inline void RawStmt::set_allocated_stmt(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.stmt_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.stmt_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RawStmt.stmt)
}

// int32 stmt_location = 2 [json_name = "stmt_location"];
inline void RawStmt::clear_stmt_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stmt_location_ = 0;
}
inline ::int32_t RawStmt::stmt_location() const {
  // @@protoc_insertion_point(field_get:pg_query.RawStmt.stmt_location)
  return _internal_stmt_location();
}
inline void RawStmt::set_stmt_location(::int32_t value) {
  _internal_set_stmt_location(value);
  // @@protoc_insertion_point(field_set:pg_query.RawStmt.stmt_location)
}
inline ::int32_t RawStmt::_internal_stmt_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.stmt_location_;
}
inline void RawStmt::_internal_set_stmt_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.stmt_location_ = value;
}

// int32 stmt_len = 3 [json_name = "stmt_len"];
inline void RawStmt::clear_stmt_len() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stmt_len_ = 0;
}
inline ::int32_t RawStmt::stmt_len() const {
  // @@protoc_insertion_point(field_get:pg_query.RawStmt.stmt_len)
  return _internal_stmt_len();
}
inline void RawStmt::set_stmt_len(::int32_t value) {
  _internal_set_stmt_len(value);
  // @@protoc_insertion_point(field_set:pg_query.RawStmt.stmt_len)
}
inline ::int32_t RawStmt::_internal_stmt_len() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.stmt_len_;
}
inline void RawStmt::_internal_set_stmt_len(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.stmt_len_ = value;
}

// -------------------------------------------------------------------

// InsertStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool InsertStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void InsertStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& InsertStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& InsertStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.InsertStmt.relation)
  return _internal_relation();
}
inline void InsertStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InsertStmt.relation)
}
inline ::pg_query::RangeVar* InsertStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* InsertStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.InsertStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* InsertStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* InsertStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.relation)
  return _msg;
}
inline void InsertStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@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 _internal_cols().size();
}
inline int InsertStmt::cols_size() const {
  return _internal_cols_size();
}
inline void InsertStmt::clear_cols() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cols_.Clear();
}
inline ::pg_query::Node* InsertStmt::mutable_cols(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.cols)
  return _internal_mutable_cols()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* InsertStmt::mutable_cols()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.InsertStmt.cols)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_cols();
}
inline const ::pg_query::Node& InsertStmt::cols(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.InsertStmt.cols)
  return _internal_cols().Get(index);
}
inline ::pg_query::Node* InsertStmt::add_cols() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_cols()->Add();
  // @@protoc_insertion_point(field_add:pg_query.InsertStmt.cols)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& InsertStmt::cols() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.InsertStmt.cols)
  return _internal_cols();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
InsertStmt::_internal_cols() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cols_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
InsertStmt::_internal_mutable_cols() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.cols_;
}

// .pg_query.Node select_stmt = 3 [json_name = "selectStmt"];
inline bool InsertStmt::has_select_stmt() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.select_stmt_ != nullptr);
  return value;
}
inline void InsertStmt::clear_select_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.select_stmt_ != nullptr) _impl_.select_stmt_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& InsertStmt::_internal_select_stmt() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.select_stmt_);
  }
  _impl_.select_stmt_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InsertStmt.select_stmt)
}
inline ::pg_query::Node* InsertStmt::release_select_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.select_stmt_;
  _impl_.select_stmt_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* InsertStmt::unsafe_arena_release_select_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.InsertStmt.select_stmt)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.select_stmt_;
  _impl_.select_stmt_ = nullptr;
  return temp;
}
inline ::pg_query::Node* InsertStmt::_internal_mutable_select_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.select_stmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.select_stmt_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.select_stmt_;
}
inline ::pg_query::Node* InsertStmt::mutable_select_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_select_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.select_stmt)
  return _msg;
}
inline void InsertStmt::set_allocated_select_stmt(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.select_stmt_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.select_stmt_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.InsertStmt.select_stmt)
}

// .pg_query.OnConflictClause on_conflict_clause = 4 [json_name = "onConflictClause"];
inline bool InsertStmt::has_on_conflict_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.on_conflict_clause_ != nullptr);
  return value;
}
inline void InsertStmt::clear_on_conflict_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.on_conflict_clause_ != nullptr) _impl_.on_conflict_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::OnConflictClause& InsertStmt::_internal_on_conflict_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::OnConflictClause* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.on_conflict_clause_);
  }
  _impl_.on_conflict_clause_ = reinterpret_cast<::pg_query::OnConflictClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InsertStmt.on_conflict_clause)
}
inline ::pg_query::OnConflictClause* InsertStmt::release_on_conflict_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::OnConflictClause* released = _impl_.on_conflict_clause_;
  _impl_.on_conflict_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::OnConflictClause* InsertStmt::unsafe_arena_release_on_conflict_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.InsertStmt.on_conflict_clause)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::OnConflictClause* temp = _impl_.on_conflict_clause_;
  _impl_.on_conflict_clause_ = nullptr;
  return temp;
}
inline ::pg_query::OnConflictClause* InsertStmt::_internal_mutable_on_conflict_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.on_conflict_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::OnConflictClause>(GetArena());
    _impl_.on_conflict_clause_ = reinterpret_cast<::pg_query::OnConflictClause*>(p);
  }
  return _impl_.on_conflict_clause_;
}
inline ::pg_query::OnConflictClause* InsertStmt::mutable_on_conflict_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::OnConflictClause* _msg = _internal_mutable_on_conflict_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.on_conflict_clause)
  return _msg;
}
inline void InsertStmt::set_allocated_on_conflict_clause(::pg_query::OnConflictClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::OnConflictClause*>(_impl_.on_conflict_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::OnConflictClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.on_conflict_clause_ = reinterpret_cast<::pg_query::OnConflictClause*>(value);
  // @@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 _internal_returning_list().size();
}
inline int InsertStmt::returning_list_size() const {
  return _internal_returning_list_size();
}
inline void InsertStmt::clear_returning_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.returning_list_.Clear();
}
inline ::pg_query::Node* InsertStmt::mutable_returning_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.returning_list)
  return _internal_mutable_returning_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* InsertStmt::mutable_returning_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.InsertStmt.returning_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_returning_list();
}
inline const ::pg_query::Node& InsertStmt::returning_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.InsertStmt.returning_list)
  return _internal_returning_list().Get(index);
}
inline ::pg_query::Node* InsertStmt::add_returning_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_returning_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.InsertStmt.returning_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& InsertStmt::returning_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.InsertStmt.returning_list)
  return _internal_returning_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
InsertStmt::_internal_returning_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.returning_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
InsertStmt::_internal_mutable_returning_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.returning_list_;
}

// .pg_query.WithClause with_clause = 6 [json_name = "withClause"];
inline bool InsertStmt::has_with_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.with_clause_ != nullptr);
  return value;
}
inline void InsertStmt::clear_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.with_clause_ != nullptr) _impl_.with_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::pg_query::WithClause& InsertStmt::_internal_with_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::WithClause* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.with_clause_);
  }
  _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InsertStmt.with_clause)
}
inline ::pg_query::WithClause* InsertStmt::release_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::WithClause* released = _impl_.with_clause_;
  _impl_.with_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::WithClause* InsertStmt::unsafe_arena_release_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.InsertStmt.with_clause)

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::WithClause* temp = _impl_.with_clause_;
  _impl_.with_clause_ = nullptr;
  return temp;
}
inline ::pg_query::WithClause* InsertStmt::_internal_mutable_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.with_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArena());
    _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(p);
  }
  return _impl_.with_clause_;
}
inline ::pg_query::WithClause* InsertStmt::mutable_with_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::WithClause* _msg = _internal_mutable_with_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.with_clause)
  return _msg;
}
inline void InsertStmt::set_allocated_with_clause(::pg_query::WithClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::WithClause*>(_impl_.with_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::WithClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }

  _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.InsertStmt.with_clause)
}

// .pg_query.OverridingKind override = 7 [json_name = "override"];
inline void InsertStmt::clear_override() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.override_ = 0;
}
inline ::pg_query::OverridingKind InsertStmt::override() const {
  // @@protoc_insertion_point(field_get:pg_query.InsertStmt.override)
  return _internal_override();
}
inline void InsertStmt::set_override(::pg_query::OverridingKind value) {
  _internal_set_override(value);
  // @@protoc_insertion_point(field_set:pg_query.InsertStmt.override)
}
inline ::pg_query::OverridingKind InsertStmt::_internal_override() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::OverridingKind>(_impl_.override_);
}
inline void InsertStmt::_internal_set_override(::pg_query::OverridingKind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.override_ = value;
}

// -------------------------------------------------------------------

// DeleteStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool DeleteStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void DeleteStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& DeleteStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& DeleteStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.relation)
  return _internal_relation();
}
inline void DeleteStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DeleteStmt.relation)
}
inline ::pg_query::RangeVar* DeleteStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* DeleteStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DeleteStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* DeleteStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* DeleteStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.DeleteStmt.relation)
  return _msg;
}
inline void DeleteStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@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 _internal_using_clause().size();
}
inline int DeleteStmt::using_clause_size() const {
  return _internal_using_clause_size();
}
inline void DeleteStmt::clear_using_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.using_clause_.Clear();
}
inline ::pg_query::Node* DeleteStmt::mutable_using_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.DeleteStmt.using_clause)
  return _internal_mutable_using_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* DeleteStmt::mutable_using_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DeleteStmt.using_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_using_clause();
}
inline const ::pg_query::Node& DeleteStmt::using_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.using_clause)
  return _internal_using_clause().Get(index);
}
inline ::pg_query::Node* DeleteStmt::add_using_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_using_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.DeleteStmt.using_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& DeleteStmt::using_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.DeleteStmt.using_clause)
  return _internal_using_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
DeleteStmt::_internal_using_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.using_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
DeleteStmt::_internal_mutable_using_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.using_clause_;
}

// .pg_query.Node where_clause = 3 [json_name = "whereClause"];
inline bool DeleteStmt::has_where_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.where_clause_ != nullptr);
  return value;
}
inline void DeleteStmt::clear_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.where_clause_ != nullptr) _impl_.where_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& DeleteStmt::_internal_where_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.where_clause_);
  }
  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DeleteStmt.where_clause)
}
inline ::pg_query::Node* DeleteStmt::release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* DeleteStmt::unsafe_arena_release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DeleteStmt.where_clause)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* DeleteStmt::_internal_mutable_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.where_clause_;
}
inline ::pg_query::Node* DeleteStmt::mutable_where_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_where_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.DeleteStmt.where_clause)
  return _msg;
}
inline void DeleteStmt::set_allocated_where_clause(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.where_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_returning_list().size();
}
inline int DeleteStmt::returning_list_size() const {
  return _internal_returning_list_size();
}
inline void DeleteStmt::clear_returning_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.returning_list_.Clear();
}
inline ::pg_query::Node* DeleteStmt::mutable_returning_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.DeleteStmt.returning_list)
  return _internal_mutable_returning_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* DeleteStmt::mutable_returning_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DeleteStmt.returning_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_returning_list();
}
inline const ::pg_query::Node& DeleteStmt::returning_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.returning_list)
  return _internal_returning_list().Get(index);
}
inline ::pg_query::Node* DeleteStmt::add_returning_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_returning_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.DeleteStmt.returning_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& DeleteStmt::returning_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.DeleteStmt.returning_list)
  return _internal_returning_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
DeleteStmt::_internal_returning_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.returning_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
DeleteStmt::_internal_mutable_returning_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.returning_list_;
}

// .pg_query.WithClause with_clause = 5 [json_name = "withClause"];
inline bool DeleteStmt::has_with_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.with_clause_ != nullptr);
  return value;
}
inline void DeleteStmt::clear_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.with_clause_ != nullptr) _impl_.with_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::WithClause& DeleteStmt::_internal_with_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::WithClause* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.with_clause_);
  }
  _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DeleteStmt.with_clause)
}
inline ::pg_query::WithClause* DeleteStmt::release_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::WithClause* released = _impl_.with_clause_;
  _impl_.with_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::WithClause* DeleteStmt::unsafe_arena_release_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DeleteStmt.with_clause)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::WithClause* temp = _impl_.with_clause_;
  _impl_.with_clause_ = nullptr;
  return temp;
}
inline ::pg_query::WithClause* DeleteStmt::_internal_mutable_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.with_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArena());
    _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(p);
  }
  return _impl_.with_clause_;
}
inline ::pg_query::WithClause* DeleteStmt::mutable_with_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::WithClause* _msg = _internal_mutable_with_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.DeleteStmt.with_clause)
  return _msg;
}
inline void DeleteStmt::set_allocated_with_clause(::pg_query::WithClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::WithClause*>(_impl_.with_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::WithClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.DeleteStmt.with_clause)
}

// -------------------------------------------------------------------

// UpdateStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool UpdateStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void UpdateStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& UpdateStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& UpdateStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.relation)
  return _internal_relation();
}
inline void UpdateStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.UpdateStmt.relation)
}
inline ::pg_query::RangeVar* UpdateStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* UpdateStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.UpdateStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* UpdateStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* UpdateStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.relation)
  return _msg;
}
inline void UpdateStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@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 _internal_target_list().size();
}
inline int UpdateStmt::target_list_size() const {
  return _internal_target_list_size();
}
inline void UpdateStmt::clear_target_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.target_list_.Clear();
}
inline ::pg_query::Node* UpdateStmt::mutable_target_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.target_list)
  return _internal_mutable_target_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* UpdateStmt::mutable_target_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.UpdateStmt.target_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_target_list();
}
inline const ::pg_query::Node& UpdateStmt::target_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.target_list)
  return _internal_target_list().Get(index);
}
inline ::pg_query::Node* UpdateStmt::add_target_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_target_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.UpdateStmt.target_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& UpdateStmt::target_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.UpdateStmt.target_list)
  return _internal_target_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
UpdateStmt::_internal_target_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.target_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
UpdateStmt::_internal_mutable_target_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.target_list_;
}

// .pg_query.Node where_clause = 3 [json_name = "whereClause"];
inline bool UpdateStmt::has_where_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.where_clause_ != nullptr);
  return value;
}
inline void UpdateStmt::clear_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.where_clause_ != nullptr) _impl_.where_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& UpdateStmt::_internal_where_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.where_clause_);
  }
  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.UpdateStmt.where_clause)
}
inline ::pg_query::Node* UpdateStmt::release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* UpdateStmt::unsafe_arena_release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.UpdateStmt.where_clause)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* UpdateStmt::_internal_mutable_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.where_clause_;
}
inline ::pg_query::Node* UpdateStmt::mutable_where_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_where_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.where_clause)
  return _msg;
}
inline void UpdateStmt::set_allocated_where_clause(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.where_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_from_clause().size();
}
inline int UpdateStmt::from_clause_size() const {
  return _internal_from_clause_size();
}
inline void UpdateStmt::clear_from_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.from_clause_.Clear();
}
inline ::pg_query::Node* UpdateStmt::mutable_from_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.from_clause)
  return _internal_mutable_from_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* UpdateStmt::mutable_from_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.UpdateStmt.from_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_from_clause();
}
inline const ::pg_query::Node& UpdateStmt::from_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.from_clause)
  return _internal_from_clause().Get(index);
}
inline ::pg_query::Node* UpdateStmt::add_from_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_from_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.UpdateStmt.from_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& UpdateStmt::from_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.UpdateStmt.from_clause)
  return _internal_from_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
UpdateStmt::_internal_from_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.from_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
UpdateStmt::_internal_mutable_from_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.from_clause_;
}

// repeated .pg_query.Node returning_list = 5 [json_name = "returningList"];
inline int UpdateStmt::_internal_returning_list_size() const {
  return _internal_returning_list().size();
}
inline int UpdateStmt::returning_list_size() const {
  return _internal_returning_list_size();
}
inline void UpdateStmt::clear_returning_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.returning_list_.Clear();
}
inline ::pg_query::Node* UpdateStmt::mutable_returning_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.returning_list)
  return _internal_mutable_returning_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* UpdateStmt::mutable_returning_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.UpdateStmt.returning_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_returning_list();
}
inline const ::pg_query::Node& UpdateStmt::returning_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.returning_list)
  return _internal_returning_list().Get(index);
}
inline ::pg_query::Node* UpdateStmt::add_returning_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_returning_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.UpdateStmt.returning_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& UpdateStmt::returning_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.UpdateStmt.returning_list)
  return _internal_returning_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
UpdateStmt::_internal_returning_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.returning_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
UpdateStmt::_internal_mutable_returning_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.returning_list_;
}

// .pg_query.WithClause with_clause = 6 [json_name = "withClause"];
inline bool UpdateStmt::has_with_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.with_clause_ != nullptr);
  return value;
}
inline void UpdateStmt::clear_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.with_clause_ != nullptr) _impl_.with_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::WithClause& UpdateStmt::_internal_with_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::WithClause* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.with_clause_);
  }
  _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.UpdateStmt.with_clause)
}
inline ::pg_query::WithClause* UpdateStmt::release_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::WithClause* released = _impl_.with_clause_;
  _impl_.with_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::WithClause* UpdateStmt::unsafe_arena_release_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.UpdateStmt.with_clause)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::WithClause* temp = _impl_.with_clause_;
  _impl_.with_clause_ = nullptr;
  return temp;
}
inline ::pg_query::WithClause* UpdateStmt::_internal_mutable_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.with_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArena());
    _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(p);
  }
  return _impl_.with_clause_;
}
inline ::pg_query::WithClause* UpdateStmt::mutable_with_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::WithClause* _msg = _internal_mutable_with_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.with_clause)
  return _msg;
}
inline void UpdateStmt::set_allocated_with_clause(::pg_query::WithClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::WithClause*>(_impl_.with_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::WithClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.UpdateStmt.with_clause)
}

// -------------------------------------------------------------------

// MergeStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool MergeStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void MergeStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& MergeStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& MergeStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MergeStmt.relation)
  return _internal_relation();
}
inline void MergeStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MergeStmt.relation)
}
inline ::pg_query::RangeVar* MergeStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* MergeStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.MergeStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* MergeStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* MergeStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.MergeStmt.relation)
  return _msg;
}
inline void MergeStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.MergeStmt.relation)
}

// .pg_query.Node source_relation = 2 [json_name = "sourceRelation"];
inline bool MergeStmt::has_source_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.source_relation_ != nullptr);
  return value;
}
inline void MergeStmt::clear_source_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.source_relation_ != nullptr) _impl_.source_relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& MergeStmt::_internal_source_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.source_relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& MergeStmt::source_relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MergeStmt.source_relation)
  return _internal_source_relation();
}
inline void MergeStmt::unsafe_arena_set_allocated_source_relation(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.source_relation_);
  }
  _impl_.source_relation_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MergeStmt.source_relation)
}
inline ::pg_query::Node* MergeStmt::release_source_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.source_relation_;
  _impl_.source_relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* MergeStmt::unsafe_arena_release_source_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.MergeStmt.source_relation)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.source_relation_;
  _impl_.source_relation_ = nullptr;
  return temp;
}
inline ::pg_query::Node* MergeStmt::_internal_mutable_source_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.source_relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.source_relation_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.source_relation_;
}
inline ::pg_query::Node* MergeStmt::mutable_source_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_source_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.MergeStmt.source_relation)
  return _msg;
}
inline void MergeStmt::set_allocated_source_relation(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.source_relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.source_relation_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.MergeStmt.source_relation)
}

// .pg_query.Node join_condition = 3 [json_name = "joinCondition"];
inline bool MergeStmt::has_join_condition() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.join_condition_ != nullptr);
  return value;
}
inline void MergeStmt::clear_join_condition() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.join_condition_ != nullptr) _impl_.join_condition_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& MergeStmt::_internal_join_condition() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.join_condition_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& MergeStmt::join_condition() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MergeStmt.join_condition)
  return _internal_join_condition();
}
inline void MergeStmt::unsafe_arena_set_allocated_join_condition(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.join_condition_);
  }
  _impl_.join_condition_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MergeStmt.join_condition)
}
inline ::pg_query::Node* MergeStmt::release_join_condition() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.join_condition_;
  _impl_.join_condition_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* MergeStmt::unsafe_arena_release_join_condition() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.MergeStmt.join_condition)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.join_condition_;
  _impl_.join_condition_ = nullptr;
  return temp;
}
inline ::pg_query::Node* MergeStmt::_internal_mutable_join_condition() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.join_condition_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.join_condition_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.join_condition_;
}
inline ::pg_query::Node* MergeStmt::mutable_join_condition() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_join_condition();
  // @@protoc_insertion_point(field_mutable:pg_query.MergeStmt.join_condition)
  return _msg;
}
inline void MergeStmt::set_allocated_join_condition(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.join_condition_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.join_condition_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.MergeStmt.join_condition)
}

// repeated .pg_query.Node merge_when_clauses = 4 [json_name = "mergeWhenClauses"];
inline int MergeStmt::_internal_merge_when_clauses_size() const {
  return _internal_merge_when_clauses().size();
}
inline int MergeStmt::merge_when_clauses_size() const {
  return _internal_merge_when_clauses_size();
}
inline void MergeStmt::clear_merge_when_clauses() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.merge_when_clauses_.Clear();
}
inline ::pg_query::Node* MergeStmt::mutable_merge_when_clauses(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.MergeStmt.merge_when_clauses)
  return _internal_mutable_merge_when_clauses()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* MergeStmt::mutable_merge_when_clauses()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.MergeStmt.merge_when_clauses)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_merge_when_clauses();
}
inline const ::pg_query::Node& MergeStmt::merge_when_clauses(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MergeStmt.merge_when_clauses)
  return _internal_merge_when_clauses().Get(index);
}
inline ::pg_query::Node* MergeStmt::add_merge_when_clauses() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_merge_when_clauses()->Add();
  // @@protoc_insertion_point(field_add:pg_query.MergeStmt.merge_when_clauses)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& MergeStmt::merge_when_clauses() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.MergeStmt.merge_when_clauses)
  return _internal_merge_when_clauses();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
MergeStmt::_internal_merge_when_clauses() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.merge_when_clauses_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
MergeStmt::_internal_mutable_merge_when_clauses() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.merge_when_clauses_;
}

// .pg_query.WithClause with_clause = 5 [json_name = "withClause"];
inline bool MergeStmt::has_with_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.with_clause_ != nullptr);
  return value;
}
inline void MergeStmt::clear_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.with_clause_ != nullptr) _impl_.with_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::pg_query::WithClause& MergeStmt::_internal_with_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::WithClause* p = _impl_.with_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::WithClause&>(::pg_query::_WithClause_default_instance_);
}
inline const ::pg_query::WithClause& MergeStmt::with_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.MergeStmt.with_clause)
  return _internal_with_clause();
}
inline void MergeStmt::unsafe_arena_set_allocated_with_clause(::pg_query::WithClause* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.with_clause_);
  }
  _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MergeStmt.with_clause)
}
inline ::pg_query::WithClause* MergeStmt::release_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::WithClause* released = _impl_.with_clause_;
  _impl_.with_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::WithClause* MergeStmt::unsafe_arena_release_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.MergeStmt.with_clause)

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::WithClause* temp = _impl_.with_clause_;
  _impl_.with_clause_ = nullptr;
  return temp;
}
inline ::pg_query::WithClause* MergeStmt::_internal_mutable_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.with_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArena());
    _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(p);
  }
  return _impl_.with_clause_;
}
inline ::pg_query::WithClause* MergeStmt::mutable_with_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::WithClause* _msg = _internal_mutable_with_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.MergeStmt.with_clause)
  return _msg;
}
inline void MergeStmt::set_allocated_with_clause(::pg_query::WithClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::WithClause*>(_impl_.with_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::WithClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }

  _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.MergeStmt.with_clause)
}

// -------------------------------------------------------------------

// SelectStmt

// repeated .pg_query.Node distinct_clause = 1 [json_name = "distinctClause"];
inline int SelectStmt::_internal_distinct_clause_size() const {
  return _internal_distinct_clause().size();
}
inline int SelectStmt::distinct_clause_size() const {
  return _internal_distinct_clause_size();
}
inline void SelectStmt::clear_distinct_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.distinct_clause_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_distinct_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.distinct_clause)
  return _internal_mutable_distinct_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SelectStmt::mutable_distinct_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.distinct_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_distinct_clause();
}
inline const ::pg_query::Node& SelectStmt::distinct_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.distinct_clause)
  return _internal_distinct_clause().Get(index);
}
inline ::pg_query::Node* SelectStmt::add_distinct_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_distinct_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.distinct_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SelectStmt::distinct_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.distinct_clause)
  return _internal_distinct_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SelectStmt::_internal_distinct_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.distinct_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SelectStmt::_internal_mutable_distinct_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.distinct_clause_;
}

// .pg_query.IntoClause into_clause = 2 [json_name = "intoClause"];
inline bool SelectStmt::has_into_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.into_clause_ != nullptr);
  return value;
}
inline void SelectStmt::clear_into_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.into_clause_ != nullptr) _impl_.into_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::IntoClause& SelectStmt::_internal_into_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::IntoClause* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.into_clause_);
  }
  _impl_.into_clause_ = reinterpret_cast<::pg_query::IntoClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.into_clause)
}
inline ::pg_query::IntoClause* SelectStmt::release_into_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::IntoClause* released = _impl_.into_clause_;
  _impl_.into_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::IntoClause* SelectStmt::unsafe_arena_release_into_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.into_clause)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::IntoClause* temp = _impl_.into_clause_;
  _impl_.into_clause_ = nullptr;
  return temp;
}
inline ::pg_query::IntoClause* SelectStmt::_internal_mutable_into_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.into_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::IntoClause>(GetArena());
    _impl_.into_clause_ = reinterpret_cast<::pg_query::IntoClause*>(p);
  }
  return _impl_.into_clause_;
}
inline ::pg_query::IntoClause* SelectStmt::mutable_into_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::IntoClause* _msg = _internal_mutable_into_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.into_clause)
  return _msg;
}
inline void SelectStmt::set_allocated_into_clause(::pg_query::IntoClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::IntoClause*>(_impl_.into_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::IntoClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.into_clause_ = reinterpret_cast<::pg_query::IntoClause*>(value);
  // @@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 _internal_target_list().size();
}
inline int SelectStmt::target_list_size() const {
  return _internal_target_list_size();
}
inline void SelectStmt::clear_target_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.target_list_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_target_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.target_list)
  return _internal_mutable_target_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SelectStmt::mutable_target_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.target_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_target_list();
}
inline const ::pg_query::Node& SelectStmt::target_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.target_list)
  return _internal_target_list().Get(index);
}
inline ::pg_query::Node* SelectStmt::add_target_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_target_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.target_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SelectStmt::target_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.target_list)
  return _internal_target_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SelectStmt::_internal_target_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.target_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SelectStmt::_internal_mutable_target_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.target_list_;
}

// repeated .pg_query.Node from_clause = 4 [json_name = "fromClause"];
inline int SelectStmt::_internal_from_clause_size() const {
  return _internal_from_clause().size();
}
inline int SelectStmt::from_clause_size() const {
  return _internal_from_clause_size();
}
inline void SelectStmt::clear_from_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.from_clause_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_from_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.from_clause)
  return _internal_mutable_from_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SelectStmt::mutable_from_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.from_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_from_clause();
}
inline const ::pg_query::Node& SelectStmt::from_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.from_clause)
  return _internal_from_clause().Get(index);
}
inline ::pg_query::Node* SelectStmt::add_from_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_from_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.from_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SelectStmt::from_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.from_clause)
  return _internal_from_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SelectStmt::_internal_from_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.from_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SelectStmt::_internal_mutable_from_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.from_clause_;
}

// .pg_query.Node where_clause = 5 [json_name = "whereClause"];
inline bool SelectStmt::has_where_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.where_clause_ != nullptr);
  return value;
}
inline void SelectStmt::clear_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.where_clause_ != nullptr) _impl_.where_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& SelectStmt::_internal_where_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.where_clause_);
  }
  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.where_clause)
}
inline ::pg_query::Node* SelectStmt::release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SelectStmt::unsafe_arena_release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.where_clause)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SelectStmt::_internal_mutable_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.where_clause_;
}
inline ::pg_query::Node* SelectStmt::mutable_where_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_where_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.where_clause)
  return _msg;
}
inline void SelectStmt::set_allocated_where_clause(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.where_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_group_clause().size();
}
inline int SelectStmt::group_clause_size() const {
  return _internal_group_clause_size();
}
inline void SelectStmt::clear_group_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.group_clause_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_group_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.group_clause)
  return _internal_mutable_group_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SelectStmt::mutable_group_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.group_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_group_clause();
}
inline const ::pg_query::Node& SelectStmt::group_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.group_clause)
  return _internal_group_clause().Get(index);
}
inline ::pg_query::Node* SelectStmt::add_group_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_group_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.group_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SelectStmt::group_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.group_clause)
  return _internal_group_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SelectStmt::_internal_group_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.group_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SelectStmt::_internal_mutable_group_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.group_clause_;
}

// bool group_distinct = 7 [json_name = "groupDistinct"];
inline void SelectStmt::clear_group_distinct() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.group_distinct_ = false;
}
inline bool SelectStmt::group_distinct() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.group_distinct)
  return _internal_group_distinct();
}
inline void SelectStmt::set_group_distinct(bool value) {
  _internal_set_group_distinct(value);
  // @@protoc_insertion_point(field_set:pg_query.SelectStmt.group_distinct)
}
inline bool SelectStmt::_internal_group_distinct() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.group_distinct_;
}
inline void SelectStmt::_internal_set_group_distinct(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.group_distinct_ = value;
}

// .pg_query.Node having_clause = 8 [json_name = "havingClause"];
inline bool SelectStmt::has_having_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.having_clause_ != nullptr);
  return value;
}
inline void SelectStmt::clear_having_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.having_clause_ != nullptr) _impl_.having_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& SelectStmt::_internal_having_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.having_clause_);
  }
  _impl_.having_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.having_clause)
}
inline ::pg_query::Node* SelectStmt::release_having_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.having_clause_;
  _impl_.having_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SelectStmt::unsafe_arena_release_having_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.having_clause)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.having_clause_;
  _impl_.having_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SelectStmt::_internal_mutable_having_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.having_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.having_clause_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.having_clause_;
}
inline ::pg_query::Node* SelectStmt::mutable_having_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_having_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.having_clause)
  return _msg;
}
inline void SelectStmt::set_allocated_having_clause(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.having_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.having_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.having_clause)
}

// repeated .pg_query.Node window_clause = 9 [json_name = "windowClause"];
inline int SelectStmt::_internal_window_clause_size() const {
  return _internal_window_clause().size();
}
inline int SelectStmt::window_clause_size() const {
  return _internal_window_clause_size();
}
inline void SelectStmt::clear_window_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.window_clause_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_window_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.window_clause)
  return _internal_mutable_window_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SelectStmt::mutable_window_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.window_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_window_clause();
}
inline const ::pg_query::Node& SelectStmt::window_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.window_clause)
  return _internal_window_clause().Get(index);
}
inline ::pg_query::Node* SelectStmt::add_window_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_window_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.window_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SelectStmt::window_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.window_clause)
  return _internal_window_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SelectStmt::_internal_window_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.window_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SelectStmt::_internal_mutable_window_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.window_clause_;
}

// repeated .pg_query.Node values_lists = 10 [json_name = "valuesLists"];
inline int SelectStmt::_internal_values_lists_size() const {
  return _internal_values_lists().size();
}
inline int SelectStmt::values_lists_size() const {
  return _internal_values_lists_size();
}
inline void SelectStmt::clear_values_lists() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.values_lists_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_values_lists(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.values_lists)
  return _internal_mutable_values_lists()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SelectStmt::mutable_values_lists()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.values_lists)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_values_lists();
}
inline const ::pg_query::Node& SelectStmt::values_lists(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.values_lists)
  return _internal_values_lists().Get(index);
}
inline ::pg_query::Node* SelectStmt::add_values_lists() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_values_lists()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.values_lists)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SelectStmt::values_lists() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.values_lists)
  return _internal_values_lists();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SelectStmt::_internal_values_lists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.values_lists_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SelectStmt::_internal_mutable_values_lists() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.values_lists_;
}

// repeated .pg_query.Node sort_clause = 11 [json_name = "sortClause"];
inline int SelectStmt::_internal_sort_clause_size() const {
  return _internal_sort_clause().size();
}
inline int SelectStmt::sort_clause_size() const {
  return _internal_sort_clause_size();
}
inline void SelectStmt::clear_sort_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.sort_clause_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_sort_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.sort_clause)
  return _internal_mutable_sort_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SelectStmt::mutable_sort_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.sort_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_sort_clause();
}
inline const ::pg_query::Node& SelectStmt::sort_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.sort_clause)
  return _internal_sort_clause().Get(index);
}
inline ::pg_query::Node* SelectStmt::add_sort_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_sort_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.sort_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SelectStmt::sort_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.sort_clause)
  return _internal_sort_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SelectStmt::_internal_sort_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.sort_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SelectStmt::_internal_mutable_sort_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.sort_clause_;
}

// .pg_query.Node limit_offset = 12 [json_name = "limitOffset"];
inline bool SelectStmt::has_limit_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.limit_offset_ != nullptr);
  return value;
}
inline void SelectStmt::clear_limit_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.limit_offset_ != nullptr) _impl_.limit_offset_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::pg_query::Node& SelectStmt::_internal_limit_offset() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.limit_offset_);
  }
  _impl_.limit_offset_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.limit_offset)
}
inline ::pg_query::Node* SelectStmt::release_limit_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::Node* released = _impl_.limit_offset_;
  _impl_.limit_offset_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SelectStmt::unsafe_arena_release_limit_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.limit_offset)

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::Node* temp = _impl_.limit_offset_;
  _impl_.limit_offset_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SelectStmt::_internal_mutable_limit_offset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.limit_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.limit_offset_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.limit_offset_;
}
inline ::pg_query::Node* SelectStmt::mutable_limit_offset() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_limit_offset();
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.limit_offset)
  return _msg;
}
inline void SelectStmt::set_allocated_limit_offset(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.limit_offset_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }

  _impl_.limit_offset_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.limit_offset)
}

// .pg_query.Node limit_count = 13 [json_name = "limitCount"];
inline bool SelectStmt::has_limit_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.limit_count_ != nullptr);
  return value;
}
inline void SelectStmt::clear_limit_count() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.limit_count_ != nullptr) _impl_.limit_count_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::pg_query::Node& SelectStmt::_internal_limit_count() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.limit_count_);
  }
  _impl_.limit_count_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.limit_count)
}
inline ::pg_query::Node* SelectStmt::release_limit_count() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000010u;
  ::pg_query::Node* released = _impl_.limit_count_;
  _impl_.limit_count_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SelectStmt::unsafe_arena_release_limit_count() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.limit_count)

  _impl_._has_bits_[0] &= ~0x00000010u;
  ::pg_query::Node* temp = _impl_.limit_count_;
  _impl_.limit_count_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SelectStmt::_internal_mutable_limit_count() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.limit_count_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.limit_count_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.limit_count_;
}
inline ::pg_query::Node* SelectStmt::mutable_limit_count() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_limit_count();
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.limit_count)
  return _msg;
}
inline void SelectStmt::set_allocated_limit_count(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.limit_count_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }

  _impl_.limit_count_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.limit_count)
}

// .pg_query.LimitOption limit_option = 14 [json_name = "limitOption"];
inline void SelectStmt::clear_limit_option() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.limit_option_ = 0;
}
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::set_limit_option(::pg_query::LimitOption value) {
  _internal_set_limit_option(value);
  // @@protoc_insertion_point(field_set:pg_query.SelectStmt.limit_option)
}
inline ::pg_query::LimitOption SelectStmt::_internal_limit_option() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::LimitOption>(_impl_.limit_option_);
}
inline void SelectStmt::_internal_set_limit_option(::pg_query::LimitOption value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.limit_option_ = value;
}

// repeated .pg_query.Node locking_clause = 15 [json_name = "lockingClause"];
inline int SelectStmt::_internal_locking_clause_size() const {
  return _internal_locking_clause().size();
}
inline int SelectStmt::locking_clause_size() const {
  return _internal_locking_clause_size();
}
inline void SelectStmt::clear_locking_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.locking_clause_.Clear();
}
inline ::pg_query::Node* SelectStmt::mutable_locking_clause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.locking_clause)
  return _internal_mutable_locking_clause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SelectStmt::mutable_locking_clause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.locking_clause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_locking_clause();
}
inline const ::pg_query::Node& SelectStmt::locking_clause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.locking_clause)
  return _internal_locking_clause().Get(index);
}
inline ::pg_query::Node* SelectStmt::add_locking_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_locking_clause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SelectStmt.locking_clause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SelectStmt::locking_clause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SelectStmt.locking_clause)
  return _internal_locking_clause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SelectStmt::_internal_locking_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.locking_clause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SelectStmt::_internal_mutable_locking_clause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.locking_clause_;
}

// .pg_query.WithClause with_clause = 16 [json_name = "withClause"];
inline bool SelectStmt::has_with_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.with_clause_ != nullptr);
  return value;
}
inline void SelectStmt::clear_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.with_clause_ != nullptr) _impl_.with_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::pg_query::WithClause& SelectStmt::_internal_with_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::WithClause* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.with_clause_);
  }
  _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.with_clause)
}
inline ::pg_query::WithClause* SelectStmt::release_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000020u;
  ::pg_query::WithClause* released = _impl_.with_clause_;
  _impl_.with_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::WithClause* SelectStmt::unsafe_arena_release_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.with_clause)

  _impl_._has_bits_[0] &= ~0x00000020u;
  ::pg_query::WithClause* temp = _impl_.with_clause_;
  _impl_.with_clause_ = nullptr;
  return temp;
}
inline ::pg_query::WithClause* SelectStmt::_internal_mutable_with_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.with_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArena());
    _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(p);
  }
  return _impl_.with_clause_;
}
inline ::pg_query::WithClause* SelectStmt::mutable_with_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::WithClause* _msg = _internal_mutable_with_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.with_clause)
  return _msg;
}
inline void SelectStmt::set_allocated_with_clause(::pg_query::WithClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::WithClause*>(_impl_.with_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::WithClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }

  _impl_.with_clause_ = reinterpret_cast<::pg_query::WithClause*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.with_clause)
}

// .pg_query.SetOperation op = 17 [json_name = "op"];
inline void SelectStmt::clear_op() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.op_ = 0;
}
inline ::pg_query::SetOperation SelectStmt::op() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.op)
  return _internal_op();
}
inline void SelectStmt::set_op(::pg_query::SetOperation value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:pg_query.SelectStmt.op)
}
inline ::pg_query::SetOperation SelectStmt::_internal_op() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::SetOperation>(_impl_.op_);
}
inline void SelectStmt::_internal_set_op(::pg_query::SetOperation value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.op_ = value;
}

// bool all = 18 [json_name = "all"];
inline void SelectStmt::clear_all() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.all_ = false;
}
inline bool SelectStmt::all() const {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.all)
  return _internal_all();
}
inline void SelectStmt::set_all(bool value) {
  _internal_set_all(value);
  // @@protoc_insertion_point(field_set:pg_query.SelectStmt.all)
}
inline bool SelectStmt::_internal_all() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.all_;
}
inline void SelectStmt::_internal_set_all(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.all_ = value;
}

// .pg_query.SelectStmt larg = 19 [json_name = "larg"];
inline bool SelectStmt::has_larg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.larg_ != nullptr);
  return value;
}
inline void SelectStmt::clear_larg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.larg_ != nullptr) _impl_.larg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::pg_query::SelectStmt& SelectStmt::_internal_larg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::SelectStmt* p = _impl_.larg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::SelectStmt&>(::pg_query::_SelectStmt_default_instance_);
}
inline const ::pg_query::SelectStmt& SelectStmt::larg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.larg)
  return _internal_larg();
}
inline void SelectStmt::unsafe_arena_set_allocated_larg(::pg_query::SelectStmt* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.larg_);
  }
  _impl_.larg_ = reinterpret_cast<::pg_query::SelectStmt*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.larg)
}
inline ::pg_query::SelectStmt* SelectStmt::release_larg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000040u;
  ::pg_query::SelectStmt* released = _impl_.larg_;
  _impl_.larg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::SelectStmt* SelectStmt::unsafe_arena_release_larg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.larg)

  _impl_._has_bits_[0] &= ~0x00000040u;
  ::pg_query::SelectStmt* temp = _impl_.larg_;
  _impl_.larg_ = nullptr;
  return temp;
}
inline ::pg_query::SelectStmt* SelectStmt::_internal_mutable_larg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.larg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::SelectStmt>(GetArena());
    _impl_.larg_ = reinterpret_cast<::pg_query::SelectStmt*>(p);
  }
  return _impl_.larg_;
}
inline ::pg_query::SelectStmt* SelectStmt::mutable_larg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SelectStmt* _msg = _internal_mutable_larg();
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.larg)
  return _msg;
}
inline void SelectStmt::set_allocated_larg(::pg_query::SelectStmt* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::SelectStmt*>(_impl_.larg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::SelectStmt*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }

  _impl_.larg_ = reinterpret_cast<::pg_query::SelectStmt*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.larg)
}

// .pg_query.SelectStmt rarg = 20 [json_name = "rarg"];
inline bool SelectStmt::has_rarg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.rarg_ != nullptr);
  return value;
}
inline void SelectStmt::clear_rarg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.rarg_ != nullptr) _impl_.rarg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::pg_query::SelectStmt& SelectStmt::_internal_rarg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::SelectStmt* p = _impl_.rarg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::SelectStmt&>(::pg_query::_SelectStmt_default_instance_);
}
inline const ::pg_query::SelectStmt& SelectStmt::rarg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SelectStmt.rarg)
  return _internal_rarg();
}
inline void SelectStmt::unsafe_arena_set_allocated_rarg(::pg_query::SelectStmt* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.rarg_);
  }
  _impl_.rarg_ = reinterpret_cast<::pg_query::SelectStmt*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.rarg)
}
inline ::pg_query::SelectStmt* SelectStmt::release_rarg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000080u;
  ::pg_query::SelectStmt* released = _impl_.rarg_;
  _impl_.rarg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::SelectStmt* SelectStmt::unsafe_arena_release_rarg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SelectStmt.rarg)

  _impl_._has_bits_[0] &= ~0x00000080u;
  ::pg_query::SelectStmt* temp = _impl_.rarg_;
  _impl_.rarg_ = nullptr;
  return temp;
}
inline ::pg_query::SelectStmt* SelectStmt::_internal_mutable_rarg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.rarg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::SelectStmt>(GetArena());
    _impl_.rarg_ = reinterpret_cast<::pg_query::SelectStmt*>(p);
  }
  return _impl_.rarg_;
}
inline ::pg_query::SelectStmt* SelectStmt::mutable_rarg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SelectStmt* _msg = _internal_mutable_rarg();
  // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.rarg)
  return _msg;
}
inline void SelectStmt::set_allocated_rarg(::pg_query::SelectStmt* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::SelectStmt*>(_impl_.rarg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::SelectStmt*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }

  _impl_.rarg_ = reinterpret_cast<::pg_query::SelectStmt*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.rarg)
}

// -------------------------------------------------------------------

// SetOperationStmt

// .pg_query.SetOperation op = 1 [json_name = "op"];
inline void SetOperationStmt::clear_op() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.op_ = 0;
}
inline ::pg_query::SetOperation SetOperationStmt::op() const {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.op)
  return _internal_op();
}
inline void SetOperationStmt::set_op(::pg_query::SetOperation value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:pg_query.SetOperationStmt.op)
}
inline ::pg_query::SetOperation SetOperationStmt::_internal_op() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::SetOperation>(_impl_.op_);
}
inline void SetOperationStmt::_internal_set_op(::pg_query::SetOperation value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.op_ = value;
}

// bool all = 2 [json_name = "all"];
inline void SetOperationStmt::clear_all() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.all_ = false;
}
inline bool SetOperationStmt::all() const {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.all)
  return _internal_all();
}
inline void SetOperationStmt::set_all(bool value) {
  _internal_set_all(value);
  // @@protoc_insertion_point(field_set:pg_query.SetOperationStmt.all)
}
inline bool SetOperationStmt::_internal_all() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.all_;
}
inline void SetOperationStmt::_internal_set_all(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.all_ = value;
}

// .pg_query.Node larg = 3 [json_name = "larg"];
inline bool SetOperationStmt::has_larg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.larg_ != nullptr);
  return value;
}
inline void SetOperationStmt::clear_larg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.larg_ != nullptr) _impl_.larg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& SetOperationStmt::_internal_larg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.larg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SetOperationStmt::larg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.larg)
  return _internal_larg();
}
inline void SetOperationStmt::unsafe_arena_set_allocated_larg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.larg_);
  }
  _impl_.larg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SetOperationStmt.larg)
}
inline ::pg_query::Node* SetOperationStmt::release_larg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.larg_;
  _impl_.larg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SetOperationStmt::unsafe_arena_release_larg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SetOperationStmt.larg)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.larg_;
  _impl_.larg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SetOperationStmt::_internal_mutable_larg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.larg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.larg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.larg_;
}
inline ::pg_query::Node* SetOperationStmt::mutable_larg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_larg();
  // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.larg)
  return _msg;
}
inline void SetOperationStmt::set_allocated_larg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.larg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.larg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SetOperationStmt.larg)
}

// .pg_query.Node rarg = 4 [json_name = "rarg"];
inline bool SetOperationStmt::has_rarg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.rarg_ != nullptr);
  return value;
}
inline void SetOperationStmt::clear_rarg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.rarg_ != nullptr) _impl_.rarg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& SetOperationStmt::_internal_rarg() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.rarg_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SetOperationStmt::rarg() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.rarg)
  return _internal_rarg();
}
inline void SetOperationStmt::unsafe_arena_set_allocated_rarg(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.rarg_);
  }
  _impl_.rarg_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SetOperationStmt.rarg)
}
inline ::pg_query::Node* SetOperationStmt::release_rarg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.rarg_;
  _impl_.rarg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SetOperationStmt::unsafe_arena_release_rarg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SetOperationStmt.rarg)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.rarg_;
  _impl_.rarg_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SetOperationStmt::_internal_mutable_rarg() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.rarg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.rarg_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.rarg_;
}
inline ::pg_query::Node* SetOperationStmt::mutable_rarg() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_rarg();
  // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.rarg)
  return _msg;
}
inline void SetOperationStmt::set_allocated_rarg(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.rarg_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.rarg_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_col_types().size();
}
inline int SetOperationStmt::col_types_size() const {
  return _internal_col_types_size();
}
inline void SetOperationStmt::clear_col_types() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.col_types_.Clear();
}
inline ::pg_query::Node* SetOperationStmt::mutable_col_types(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.col_types)
  return _internal_mutable_col_types()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SetOperationStmt::mutable_col_types()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SetOperationStmt.col_types)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_col_types();
}
inline const ::pg_query::Node& SetOperationStmt::col_types(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.col_types)
  return _internal_col_types().Get(index);
}
inline ::pg_query::Node* SetOperationStmt::add_col_types() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_col_types()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SetOperationStmt.col_types)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SetOperationStmt::col_types() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SetOperationStmt.col_types)
  return _internal_col_types();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SetOperationStmt::_internal_col_types() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.col_types_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SetOperationStmt::_internal_mutable_col_types() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.col_types_;
}

// repeated .pg_query.Node col_typmods = 6 [json_name = "colTypmods"];
inline int SetOperationStmt::_internal_col_typmods_size() const {
  return _internal_col_typmods().size();
}
inline int SetOperationStmt::col_typmods_size() const {
  return _internal_col_typmods_size();
}
inline void SetOperationStmt::clear_col_typmods() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.col_typmods_.Clear();
}
inline ::pg_query::Node* SetOperationStmt::mutable_col_typmods(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.col_typmods)
  return _internal_mutable_col_typmods()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SetOperationStmt::mutable_col_typmods()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SetOperationStmt.col_typmods)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_col_typmods();
}
inline const ::pg_query::Node& SetOperationStmt::col_typmods(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.col_typmods)
  return _internal_col_typmods().Get(index);
}
inline ::pg_query::Node* SetOperationStmt::add_col_typmods() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_col_typmods()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SetOperationStmt.col_typmods)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SetOperationStmt::col_typmods() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SetOperationStmt.col_typmods)
  return _internal_col_typmods();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SetOperationStmt::_internal_col_typmods() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.col_typmods_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SetOperationStmt::_internal_mutable_col_typmods() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.col_typmods_;
}

// repeated .pg_query.Node col_collations = 7 [json_name = "colCollations"];
inline int SetOperationStmt::_internal_col_collations_size() const {
  return _internal_col_collations().size();
}
inline int SetOperationStmt::col_collations_size() const {
  return _internal_col_collations_size();
}
inline void SetOperationStmt::clear_col_collations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.col_collations_.Clear();
}
inline ::pg_query::Node* SetOperationStmt::mutable_col_collations(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.col_collations)
  return _internal_mutable_col_collations()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SetOperationStmt::mutable_col_collations()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SetOperationStmt.col_collations)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_col_collations();
}
inline const ::pg_query::Node& SetOperationStmt::col_collations(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.col_collations)
  return _internal_col_collations().Get(index);
}
inline ::pg_query::Node* SetOperationStmt::add_col_collations() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_col_collations()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SetOperationStmt.col_collations)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SetOperationStmt::col_collations() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SetOperationStmt.col_collations)
  return _internal_col_collations();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SetOperationStmt::_internal_col_collations() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.col_collations_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SetOperationStmt::_internal_mutable_col_collations() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.col_collations_;
}

// repeated .pg_query.Node group_clauses = 8 [json_name = "groupClauses"];
inline int SetOperationStmt::_internal_group_clauses_size() const {
  return _internal_group_clauses().size();
}
inline int SetOperationStmt::group_clauses_size() const {
  return _internal_group_clauses_size();
}
inline void SetOperationStmt::clear_group_clauses() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.group_clauses_.Clear();
}
inline ::pg_query::Node* SetOperationStmt::mutable_group_clauses(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.group_clauses)
  return _internal_mutable_group_clauses()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* SetOperationStmt::mutable_group_clauses()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.SetOperationStmt.group_clauses)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_group_clauses();
}
inline const ::pg_query::Node& SetOperationStmt::group_clauses(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.group_clauses)
  return _internal_group_clauses().Get(index);
}
inline ::pg_query::Node* SetOperationStmt::add_group_clauses() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_group_clauses()->Add();
  // @@protoc_insertion_point(field_add:pg_query.SetOperationStmt.group_clauses)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& SetOperationStmt::group_clauses() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.SetOperationStmt.group_clauses)
  return _internal_group_clauses();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
SetOperationStmt::_internal_group_clauses() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.group_clauses_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
SetOperationStmt::_internal_mutable_group_clauses() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.group_clauses_;
}

// -------------------------------------------------------------------

// ReturnStmt

// .pg_query.Node returnval = 1 [json_name = "returnval"];
inline bool ReturnStmt::has_returnval() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.returnval_ != nullptr);
  return value;
}
inline void ReturnStmt::clear_returnval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.returnval_ != nullptr) _impl_.returnval_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& ReturnStmt::_internal_returnval() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.returnval_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ReturnStmt::returnval() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ReturnStmt.returnval)
  return _internal_returnval();
}
inline void ReturnStmt::unsafe_arena_set_allocated_returnval(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.returnval_);
  }
  _impl_.returnval_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ReturnStmt.returnval)
}
inline ::pg_query::Node* ReturnStmt::release_returnval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.returnval_;
  _impl_.returnval_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ReturnStmt::unsafe_arena_release_returnval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ReturnStmt.returnval)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.returnval_;
  _impl_.returnval_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ReturnStmt::_internal_mutable_returnval() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.returnval_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.returnval_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.returnval_;
}
inline ::pg_query::Node* ReturnStmt::mutable_returnval() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_returnval();
  // @@protoc_insertion_point(field_mutable:pg_query.ReturnStmt.returnval)
  return _msg;
}
inline void ReturnStmt::set_allocated_returnval(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.returnval_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.returnval_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ReturnStmt.returnval)
}

// -------------------------------------------------------------------

// PLAssignStmt

// string name = 1 [json_name = "name"];
inline void PLAssignStmt::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& PLAssignStmt::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PLAssignStmt.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void PLAssignStmt::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.PLAssignStmt.name)
}
inline std::string* PLAssignStmt::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.PLAssignStmt.name)
  return _s;
}
inline const std::string& PLAssignStmt::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void PLAssignStmt::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* PLAssignStmt::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* PLAssignStmt::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PLAssignStmt.name)
  return _impl_.name_.Release();
}
inline void PLAssignStmt::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.PLAssignStmt.name)
}

// repeated .pg_query.Node indirection = 2 [json_name = "indirection"];
inline int PLAssignStmt::_internal_indirection_size() const {
  return _internal_indirection().size();
}
inline int PLAssignStmt::indirection_size() const {
  return _internal_indirection_size();
}
inline void PLAssignStmt::clear_indirection() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indirection_.Clear();
}
inline ::pg_query::Node* PLAssignStmt::mutable_indirection(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.PLAssignStmt.indirection)
  return _internal_mutable_indirection()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* PLAssignStmt::mutable_indirection()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PLAssignStmt.indirection)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_indirection();
}
inline const ::pg_query::Node& PLAssignStmt::indirection(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PLAssignStmt.indirection)
  return _internal_indirection().Get(index);
}
inline ::pg_query::Node* PLAssignStmt::add_indirection() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_indirection()->Add();
  // @@protoc_insertion_point(field_add:pg_query.PLAssignStmt.indirection)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& PLAssignStmt::indirection() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.PLAssignStmt.indirection)
  return _internal_indirection();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
PLAssignStmt::_internal_indirection() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.indirection_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
PLAssignStmt::_internal_mutable_indirection() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.indirection_;
}

// int32 nnames = 3 [json_name = "nnames"];
inline void PLAssignStmt::clear_nnames() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.nnames_ = 0;
}
inline ::int32_t PLAssignStmt::nnames() const {
  // @@protoc_insertion_point(field_get:pg_query.PLAssignStmt.nnames)
  return _internal_nnames();
}
inline void PLAssignStmt::set_nnames(::int32_t value) {
  _internal_set_nnames(value);
  // @@protoc_insertion_point(field_set:pg_query.PLAssignStmt.nnames)
}
inline ::int32_t PLAssignStmt::_internal_nnames() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.nnames_;
}
inline void PLAssignStmt::_internal_set_nnames(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.nnames_ = value;
}

// .pg_query.SelectStmt val = 4 [json_name = "val"];
inline bool PLAssignStmt::has_val() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.val_ != nullptr);
  return value;
}
inline void PLAssignStmt::clear_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.val_ != nullptr) _impl_.val_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::SelectStmt& PLAssignStmt::_internal_val() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::SelectStmt* p = _impl_.val_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::SelectStmt&>(::pg_query::_SelectStmt_default_instance_);
}
inline const ::pg_query::SelectStmt& PLAssignStmt::val() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PLAssignStmt.val)
  return _internal_val();
}
inline void PLAssignStmt::unsafe_arena_set_allocated_val(::pg_query::SelectStmt* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.val_);
  }
  _impl_.val_ = reinterpret_cast<::pg_query::SelectStmt*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PLAssignStmt.val)
}
inline ::pg_query::SelectStmt* PLAssignStmt::release_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::SelectStmt* released = _impl_.val_;
  _impl_.val_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::SelectStmt* PLAssignStmt::unsafe_arena_release_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PLAssignStmt.val)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::SelectStmt* temp = _impl_.val_;
  _impl_.val_ = nullptr;
  return temp;
}
inline ::pg_query::SelectStmt* PLAssignStmt::_internal_mutable_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.val_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::SelectStmt>(GetArena());
    _impl_.val_ = reinterpret_cast<::pg_query::SelectStmt*>(p);
  }
  return _impl_.val_;
}
inline ::pg_query::SelectStmt* PLAssignStmt::mutable_val() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::SelectStmt* _msg = _internal_mutable_val();
  // @@protoc_insertion_point(field_mutable:pg_query.PLAssignStmt.val)
  return _msg;
}
inline void PLAssignStmt::set_allocated_val(::pg_query::SelectStmt* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::SelectStmt*>(_impl_.val_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::SelectStmt*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.val_ = reinterpret_cast<::pg_query::SelectStmt*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.PLAssignStmt.val)
}

// int32 location = 5 [json_name = "location"];
inline void PLAssignStmt::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t PLAssignStmt::location() const {
  // @@protoc_insertion_point(field_get:pg_query.PLAssignStmt.location)
  return _internal_location();
}
inline void PLAssignStmt::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.PLAssignStmt.location)
}
inline ::int32_t PLAssignStmt::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void PLAssignStmt::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CreateSchemaStmt

// string schemaname = 1 [json_name = "schemaname"];
inline void CreateSchemaStmt::clear_schemaname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.schemaname_.ClearToEmpty();
}
inline const std::string& CreateSchemaStmt::schemaname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateSchemaStmt.schemaname)
  return _internal_schemaname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateSchemaStmt::set_schemaname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.schemaname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateSchemaStmt.schemaname)
}
inline std::string* CreateSchemaStmt::mutable_schemaname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_schemaname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSchemaStmt.schemaname)
  return _s;
}
inline const std::string& CreateSchemaStmt::_internal_schemaname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.schemaname_.Get();
}
inline void CreateSchemaStmt::_internal_set_schemaname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.schemaname_.Set(value, GetArena());
}
inline std::string* CreateSchemaStmt::_internal_mutable_schemaname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.schemaname_.Mutable( GetArena());
}
inline std::string* CreateSchemaStmt::release_schemaname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateSchemaStmt.schemaname)
  return _impl_.schemaname_.Release();
}
inline void CreateSchemaStmt::set_allocated_schemaname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.schemaname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.schemaname_.IsDefault()) {
          _impl_.schemaname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateSchemaStmt.schemaname)
}

// .pg_query.RoleSpec authrole = 2 [json_name = "authrole"];
inline bool CreateSchemaStmt::has_authrole() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.authrole_ != nullptr);
  return value;
}
inline void CreateSchemaStmt::clear_authrole() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.authrole_ != nullptr) _impl_.authrole_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RoleSpec& CreateSchemaStmt::_internal_authrole() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RoleSpec* p = _impl_.authrole_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& CreateSchemaStmt::authrole() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateSchemaStmt.authrole)
  return _internal_authrole();
}
inline void CreateSchemaStmt::unsafe_arena_set_allocated_authrole(::pg_query::RoleSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.authrole_);
  }
  _impl_.authrole_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateSchemaStmt.authrole)
}
inline ::pg_query::RoleSpec* CreateSchemaStmt::release_authrole() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* released = _impl_.authrole_;
  _impl_.authrole_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RoleSpec* CreateSchemaStmt::unsafe_arena_release_authrole() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateSchemaStmt.authrole)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* temp = _impl_.authrole_;
  _impl_.authrole_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* CreateSchemaStmt::_internal_mutable_authrole() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.authrole_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    _impl_.authrole_ = reinterpret_cast<::pg_query::RoleSpec*>(p);
  }
  return _impl_.authrole_;
}
inline ::pg_query::RoleSpec* CreateSchemaStmt::mutable_authrole() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_authrole();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSchemaStmt.authrole)
  return _msg;
}
inline void CreateSchemaStmt::set_allocated_authrole(::pg_query::RoleSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RoleSpec*>(_impl_.authrole_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RoleSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.authrole_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  // @@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 _internal_schema_elts().size();
}
inline int CreateSchemaStmt::schema_elts_size() const {
  return _internal_schema_elts_size();
}
inline void CreateSchemaStmt::clear_schema_elts() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.schema_elts_.Clear();
}
inline ::pg_query::Node* CreateSchemaStmt::mutable_schema_elts(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSchemaStmt.schema_elts)
  return _internal_mutable_schema_elts()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateSchemaStmt::mutable_schema_elts()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateSchemaStmt.schema_elts)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_schema_elts();
}
inline const ::pg_query::Node& CreateSchemaStmt::schema_elts(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateSchemaStmt.schema_elts)
  return _internal_schema_elts().Get(index);
}
inline ::pg_query::Node* CreateSchemaStmt::add_schema_elts() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_schema_elts()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateSchemaStmt.schema_elts)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateSchemaStmt::schema_elts() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateSchemaStmt.schema_elts)
  return _internal_schema_elts();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateSchemaStmt::_internal_schema_elts() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.schema_elts_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateSchemaStmt::_internal_mutable_schema_elts() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.schema_elts_;
}

// bool if_not_exists = 4 [json_name = "if_not_exists"];
inline void CreateSchemaStmt::clear_if_not_exists() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.if_not_exists_ = false;
}
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::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateSchemaStmt.if_not_exists)
}
inline bool CreateSchemaStmt::_internal_if_not_exists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.if_not_exists_;
}
inline void CreateSchemaStmt::_internal_set_if_not_exists(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.if_not_exists_ = value;
}

// -------------------------------------------------------------------

// AlterTableStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool AlterTableStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void AlterTableStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& AlterTableStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& AlterTableStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableStmt.relation)
  return _internal_relation();
}
inline void AlterTableStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterTableStmt.relation)
}
inline ::pg_query::RangeVar* AlterTableStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* AlterTableStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterTableStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* AlterTableStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* AlterTableStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableStmt.relation)
  return _msg;
}
inline void AlterTableStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@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 _internal_cmds().size();
}
inline int AlterTableStmt::cmds_size() const {
  return _internal_cmds_size();
}
inline void AlterTableStmt::clear_cmds() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cmds_.Clear();
}
inline ::pg_query::Node* AlterTableStmt::mutable_cmds(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableStmt.cmds)
  return _internal_mutable_cmds()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterTableStmt::mutable_cmds()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTableStmt.cmds)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_cmds();
}
inline const ::pg_query::Node& AlterTableStmt::cmds(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableStmt.cmds)
  return _internal_cmds().Get(index);
}
inline ::pg_query::Node* AlterTableStmt::add_cmds() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_cmds()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterTableStmt.cmds)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterTableStmt::cmds() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterTableStmt.cmds)
  return _internal_cmds();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterTableStmt::_internal_cmds() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cmds_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterTableStmt::_internal_mutable_cmds() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.cmds_;
}

// .pg_query.ObjectType objtype = 3 [json_name = "objtype"];
inline void AlterTableStmt::clear_objtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objtype_ = 0;
}
inline ::pg_query::ObjectType AlterTableStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableStmt.objtype)
  return _internal_objtype();
}
inline void AlterTableStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableStmt.objtype)
}
inline ::pg_query::ObjectType AlterTableStmt::_internal_objtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.objtype_);
}
inline void AlterTableStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.objtype_ = value;
}

// bool missing_ok = 4 [json_name = "missing_ok"];
inline void AlterTableStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool AlterTableStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableStmt.missing_ok)
  return _internal_missing_ok();
}
inline void AlterTableStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableStmt.missing_ok)
}
inline bool AlterTableStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void AlterTableStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// -------------------------------------------------------------------

// ReplicaIdentityStmt

// string identity_type = 1 [json_name = "identity_type"];
inline void ReplicaIdentityStmt::clear_identity_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.identity_type_.ClearToEmpty();
}
inline const std::string& ReplicaIdentityStmt::identity_type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ReplicaIdentityStmt.identity_type)
  return _internal_identity_type();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ReplicaIdentityStmt::set_identity_type(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.identity_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ReplicaIdentityStmt.identity_type)
}
inline std::string* ReplicaIdentityStmt::mutable_identity_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_identity_type();
  // @@protoc_insertion_point(field_mutable:pg_query.ReplicaIdentityStmt.identity_type)
  return _s;
}
inline const std::string& ReplicaIdentityStmt::_internal_identity_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.identity_type_.Get();
}
inline void ReplicaIdentityStmt::_internal_set_identity_type(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.identity_type_.Set(value, GetArena());
}
inline std::string* ReplicaIdentityStmt::_internal_mutable_identity_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.identity_type_.Mutable( GetArena());
}
inline std::string* ReplicaIdentityStmt::release_identity_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ReplicaIdentityStmt.identity_type)
  return _impl_.identity_type_.Release();
}
inline void ReplicaIdentityStmt::set_allocated_identity_type(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.identity_type_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.identity_type_.IsDefault()) {
          _impl_.identity_type_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.ReplicaIdentityStmt.identity_type)
}

// string name = 2 [json_name = "name"];
inline void ReplicaIdentityStmt::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& ReplicaIdentityStmt::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ReplicaIdentityStmt.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ReplicaIdentityStmt::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ReplicaIdentityStmt.name)
}
inline std::string* ReplicaIdentityStmt::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.ReplicaIdentityStmt.name)
  return _s;
}
inline const std::string& ReplicaIdentityStmt::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void ReplicaIdentityStmt::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* ReplicaIdentityStmt::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* ReplicaIdentityStmt::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ReplicaIdentityStmt.name)
  return _impl_.name_.Release();
}
inline void ReplicaIdentityStmt::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.ReplicaIdentityStmt.name)
}

// -------------------------------------------------------------------

// AlterTableCmd

// .pg_query.AlterTableType subtype = 1 [json_name = "subtype"];
inline void AlterTableCmd::clear_subtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subtype_ = 0;
}
inline ::pg_query::AlterTableType AlterTableCmd::subtype() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.subtype)
  return _internal_subtype();
}
inline void AlterTableCmd::set_subtype(::pg_query::AlterTableType value) {
  _internal_set_subtype(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.subtype)
}
inline ::pg_query::AlterTableType AlterTableCmd::_internal_subtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::AlterTableType>(_impl_.subtype_);
}
inline void AlterTableCmd::_internal_set_subtype(::pg_query::AlterTableType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.subtype_ = value;
}

// string name = 2 [json_name = "name"];
inline void AlterTableCmd::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& AlterTableCmd::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterTableCmd::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.name)
}
inline std::string* AlterTableCmd::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableCmd.name)
  return _s;
}
inline const std::string& AlterTableCmd::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void AlterTableCmd::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* AlterTableCmd::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* AlterTableCmd::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterTableCmd.name)
  return _impl_.name_.Release();
}
inline void AlterTableCmd::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableCmd.name)
}

// int32 num = 3 [json_name = "num"];
inline void AlterTableCmd::clear_num() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.num_ = 0;
}
inline ::int32_t AlterTableCmd::num() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.num)
  return _internal_num();
}
inline void AlterTableCmd::set_num(::int32_t value) {
  _internal_set_num(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.num)
}
inline ::int32_t AlterTableCmd::_internal_num() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.num_;
}
inline void AlterTableCmd::_internal_set_num(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.num_ = value;
}

// .pg_query.RoleSpec newowner = 4 [json_name = "newowner"];
inline bool AlterTableCmd::has_newowner() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.newowner_ != nullptr);
  return value;
}
inline void AlterTableCmd::clear_newowner() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.newowner_ != nullptr) _impl_.newowner_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RoleSpec& AlterTableCmd::_internal_newowner() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RoleSpec* p = _impl_.newowner_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& AlterTableCmd::newowner() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.newowner)
  return _internal_newowner();
}
inline void AlterTableCmd::unsafe_arena_set_allocated_newowner(::pg_query::RoleSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.newowner_);
  }
  _impl_.newowner_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterTableCmd.newowner)
}
inline ::pg_query::RoleSpec* AlterTableCmd::release_newowner() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* released = _impl_.newowner_;
  _impl_.newowner_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RoleSpec* AlterTableCmd::unsafe_arena_release_newowner() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterTableCmd.newowner)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* temp = _impl_.newowner_;
  _impl_.newowner_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* AlterTableCmd::_internal_mutable_newowner() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.newowner_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    _impl_.newowner_ = reinterpret_cast<::pg_query::RoleSpec*>(p);
  }
  return _impl_.newowner_;
}
inline ::pg_query::RoleSpec* AlterTableCmd::mutable_newowner() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_newowner();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableCmd.newowner)
  return _msg;
}
inline void AlterTableCmd::set_allocated_newowner(::pg_query::RoleSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RoleSpec*>(_impl_.newowner_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RoleSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.newowner_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableCmd.newowner)
}

// .pg_query.Node def = 5 [json_name = "def"];
inline bool AlterTableCmd::has_def() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.def_ != nullptr);
  return value;
}
inline void AlterTableCmd::clear_def() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.def_ != nullptr) _impl_.def_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& AlterTableCmd::_internal_def() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.def_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterTableCmd::def() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.def)
  return _internal_def();
}
inline void AlterTableCmd::unsafe_arena_set_allocated_def(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.def_);
  }
  _impl_.def_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterTableCmd.def)
}
inline ::pg_query::Node* AlterTableCmd::release_def() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.def_;
  _impl_.def_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* AlterTableCmd::unsafe_arena_release_def() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterTableCmd.def)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.def_;
  _impl_.def_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterTableCmd::_internal_mutable_def() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.def_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.def_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.def_;
}
inline ::pg_query::Node* AlterTableCmd::mutable_def() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_def();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableCmd.def)
  return _msg;
}
inline void AlterTableCmd::set_allocated_def(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.def_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.def_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableCmd.def)
}

// .pg_query.DropBehavior behavior = 6 [json_name = "behavior"];
inline void AlterTableCmd::clear_behavior() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.behavior_ = 0;
}
inline ::pg_query::DropBehavior AlterTableCmd::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.behavior)
  return _internal_behavior();
}
inline void AlterTableCmd::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.behavior)
}
inline ::pg_query::DropBehavior AlterTableCmd::_internal_behavior() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::DropBehavior>(_impl_.behavior_);
}
inline void AlterTableCmd::_internal_set_behavior(::pg_query::DropBehavior value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.behavior_ = value;
}

// bool missing_ok = 7 [json_name = "missing_ok"];
inline void AlterTableCmd::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool AlterTableCmd::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.missing_ok)
  return _internal_missing_ok();
}
inline void AlterTableCmd::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.missing_ok)
}
inline bool AlterTableCmd::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void AlterTableCmd::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// bool recurse = 8 [json_name = "recurse"];
inline void AlterTableCmd::clear_recurse() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.recurse_ = false;
}
inline bool AlterTableCmd::recurse() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.recurse)
  return _internal_recurse();
}
inline void AlterTableCmd::set_recurse(bool value) {
  _internal_set_recurse(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.recurse)
}
inline bool AlterTableCmd::_internal_recurse() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.recurse_;
}
inline void AlterTableCmd::_internal_set_recurse(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.recurse_ = value;
}

// -------------------------------------------------------------------

// AlterCollationStmt

// repeated .pg_query.Node collname = 1 [json_name = "collname"];
inline int AlterCollationStmt::_internal_collname_size() const {
  return _internal_collname().size();
}
inline int AlterCollationStmt::collname_size() const {
  return _internal_collname_size();
}
inline void AlterCollationStmt::clear_collname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.collname_.Clear();
}
inline ::pg_query::Node* AlterCollationStmt::mutable_collname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterCollationStmt.collname)
  return _internal_mutable_collname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterCollationStmt::mutable_collname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterCollationStmt.collname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_collname();
}
inline const ::pg_query::Node& AlterCollationStmt::collname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterCollationStmt.collname)
  return _internal_collname().Get(index);
}
inline ::pg_query::Node* AlterCollationStmt::add_collname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_collname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterCollationStmt.collname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterCollationStmt::collname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterCollationStmt.collname)
  return _internal_collname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterCollationStmt::_internal_collname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.collname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterCollationStmt::_internal_mutable_collname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.collname_;
}

// -------------------------------------------------------------------

// AlterDomainStmt

// string subtype = 1 [json_name = "subtype"];
inline void AlterDomainStmt::clear_subtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subtype_.ClearToEmpty();
}
inline const std::string& AlterDomainStmt::subtype() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.subtype)
  return _internal_subtype();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterDomainStmt::set_subtype(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.subtype_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterDomainStmt.subtype)
}
inline std::string* AlterDomainStmt::mutable_subtype() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_subtype();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDomainStmt.subtype)
  return _s;
}
inline const std::string& AlterDomainStmt::_internal_subtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.subtype_.Get();
}
inline void AlterDomainStmt::_internal_set_subtype(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.subtype_.Set(value, GetArena());
}
inline std::string* AlterDomainStmt::_internal_mutable_subtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.subtype_.Mutable( GetArena());
}
inline std::string* AlterDomainStmt::release_subtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterDomainStmt.subtype)
  return _impl_.subtype_.Release();
}
inline void AlterDomainStmt::set_allocated_subtype(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subtype_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.subtype_.IsDefault()) {
          _impl_.subtype_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_type_name().size();
}
inline int AlterDomainStmt::type_name_size() const {
  return _internal_type_name_size();
}
inline void AlterDomainStmt::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_name_.Clear();
}
inline ::pg_query::Node* AlterDomainStmt::mutable_type_name(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDomainStmt.type_name)
  return _internal_mutable_type_name()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterDomainStmt::mutable_type_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterDomainStmt.type_name)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_type_name();
}
inline const ::pg_query::Node& AlterDomainStmt::type_name(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.type_name)
  return _internal_type_name().Get(index);
}
inline ::pg_query::Node* AlterDomainStmt::add_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_type_name()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterDomainStmt.type_name)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterDomainStmt::type_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterDomainStmt.type_name)
  return _internal_type_name();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterDomainStmt::_internal_type_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_name_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterDomainStmt::_internal_mutable_type_name() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.type_name_;
}

// string name = 3 [json_name = "name"];
inline void AlterDomainStmt::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& AlterDomainStmt::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterDomainStmt::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterDomainStmt.name)
}
inline std::string* AlterDomainStmt::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDomainStmt.name)
  return _s;
}
inline const std::string& AlterDomainStmt::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void AlterDomainStmt::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* AlterDomainStmt::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* AlterDomainStmt::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterDomainStmt.name)
  return _impl_.name_.Release();
}
inline void AlterDomainStmt::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDomainStmt.name)
}

// .pg_query.Node def = 4 [json_name = "def"];
inline bool AlterDomainStmt::has_def() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.def_ != nullptr);
  return value;
}
inline void AlterDomainStmt::clear_def() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.def_ != nullptr) _impl_.def_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& AlterDomainStmt::_internal_def() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.def_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterDomainStmt::def() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.def)
  return _internal_def();
}
inline void AlterDomainStmt::unsafe_arena_set_allocated_def(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.def_);
  }
  _impl_.def_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterDomainStmt.def)
}
inline ::pg_query::Node* AlterDomainStmt::release_def() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.def_;
  _impl_.def_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* AlterDomainStmt::unsafe_arena_release_def() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterDomainStmt.def)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.def_;
  _impl_.def_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterDomainStmt::_internal_mutable_def() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.def_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.def_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.def_;
}
inline ::pg_query::Node* AlterDomainStmt::mutable_def() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_def();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDomainStmt.def)
  return _msg;
}
inline void AlterDomainStmt::set_allocated_def(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.def_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.def_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDomainStmt.def)
}

// .pg_query.DropBehavior behavior = 5 [json_name = "behavior"];
inline void AlterDomainStmt::clear_behavior() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.behavior_ = 0;
}
inline ::pg_query::DropBehavior AlterDomainStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.behavior)
  return _internal_behavior();
}
inline void AlterDomainStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterDomainStmt.behavior)
}
inline ::pg_query::DropBehavior AlterDomainStmt::_internal_behavior() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::DropBehavior>(_impl_.behavior_);
}
inline void AlterDomainStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.behavior_ = value;
}

// bool missing_ok = 6 [json_name = "missing_ok"];
inline void AlterDomainStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool AlterDomainStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.missing_ok)
  return _internal_missing_ok();
}
inline void AlterDomainStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterDomainStmt.missing_ok)
}
inline bool AlterDomainStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void AlterDomainStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// -------------------------------------------------------------------

// GrantStmt

// bool is_grant = 1 [json_name = "is_grant"];
inline void GrantStmt::clear_is_grant() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_grant_ = false;
}
inline bool GrantStmt::is_grant() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.is_grant)
  return _internal_is_grant();
}
inline void GrantStmt::set_is_grant(bool value) {
  _internal_set_is_grant(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantStmt.is_grant)
}
inline bool GrantStmt::_internal_is_grant() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_grant_;
}
inline void GrantStmt::_internal_set_is_grant(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_grant_ = value;
}

// .pg_query.GrantTargetType targtype = 2 [json_name = "targtype"];
inline void GrantStmt::clear_targtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.targtype_ = 0;
}
inline ::pg_query::GrantTargetType GrantStmt::targtype() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.targtype)
  return _internal_targtype();
}
inline void GrantStmt::set_targtype(::pg_query::GrantTargetType value) {
  _internal_set_targtype(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantStmt.targtype)
}
inline ::pg_query::GrantTargetType GrantStmt::_internal_targtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::GrantTargetType>(_impl_.targtype_);
}
inline void GrantStmt::_internal_set_targtype(::pg_query::GrantTargetType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.targtype_ = value;
}

// .pg_query.ObjectType objtype = 3 [json_name = "objtype"];
inline void GrantStmt::clear_objtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objtype_ = 0;
}
inline ::pg_query::ObjectType GrantStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.objtype)
  return _internal_objtype();
}
inline void GrantStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantStmt.objtype)
}
inline ::pg_query::ObjectType GrantStmt::_internal_objtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.objtype_);
}
inline void GrantStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.objtype_ = value;
}

// repeated .pg_query.Node objects = 4 [json_name = "objects"];
inline int GrantStmt::_internal_objects_size() const {
  return _internal_objects().size();
}
inline int GrantStmt::objects_size() const {
  return _internal_objects_size();
}
inline void GrantStmt::clear_objects() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objects_.Clear();
}
inline ::pg_query::Node* GrantStmt::mutable_objects(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.GrantStmt.objects)
  return _internal_mutable_objects()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* GrantStmt::mutable_objects()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GrantStmt.objects)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_objects();
}
inline const ::pg_query::Node& GrantStmt::objects(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.objects)
  return _internal_objects().Get(index);
}
inline ::pg_query::Node* GrantStmt::add_objects() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_objects()->Add();
  // @@protoc_insertion_point(field_add:pg_query.GrantStmt.objects)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& GrantStmt::objects() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.GrantStmt.objects)
  return _internal_objects();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
GrantStmt::_internal_objects() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.objects_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
GrantStmt::_internal_mutable_objects() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.objects_;
}

// repeated .pg_query.Node privileges = 5 [json_name = "privileges"];
inline int GrantStmt::_internal_privileges_size() const {
  return _internal_privileges().size();
}
inline int GrantStmt::privileges_size() const {
  return _internal_privileges_size();
}
inline void GrantStmt::clear_privileges() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.privileges_.Clear();
}
inline ::pg_query::Node* GrantStmt::mutable_privileges(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.GrantStmt.privileges)
  return _internal_mutable_privileges()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* GrantStmt::mutable_privileges()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GrantStmt.privileges)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_privileges();
}
inline const ::pg_query::Node& GrantStmt::privileges(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.privileges)
  return _internal_privileges().Get(index);
}
inline ::pg_query::Node* GrantStmt::add_privileges() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_privileges()->Add();
  // @@protoc_insertion_point(field_add:pg_query.GrantStmt.privileges)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& GrantStmt::privileges() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.GrantStmt.privileges)
  return _internal_privileges();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
GrantStmt::_internal_privileges() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.privileges_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
GrantStmt::_internal_mutable_privileges() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.privileges_;
}

// repeated .pg_query.Node grantees = 6 [json_name = "grantees"];
inline int GrantStmt::_internal_grantees_size() const {
  return _internal_grantees().size();
}
inline int GrantStmt::grantees_size() const {
  return _internal_grantees_size();
}
inline void GrantStmt::clear_grantees() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.grantees_.Clear();
}
inline ::pg_query::Node* GrantStmt::mutable_grantees(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.GrantStmt.grantees)
  return _internal_mutable_grantees()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* GrantStmt::mutable_grantees()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GrantStmt.grantees)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_grantees();
}
inline const ::pg_query::Node& GrantStmt::grantees(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.grantees)
  return _internal_grantees().Get(index);
}
inline ::pg_query::Node* GrantStmt::add_grantees() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_grantees()->Add();
  // @@protoc_insertion_point(field_add:pg_query.GrantStmt.grantees)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& GrantStmt::grantees() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.GrantStmt.grantees)
  return _internal_grantees();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
GrantStmt::_internal_grantees() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.grantees_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
GrantStmt::_internal_mutable_grantees() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.grantees_;
}

// bool grant_option = 7 [json_name = "grant_option"];
inline void GrantStmt::clear_grant_option() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.grant_option_ = false;
}
inline bool GrantStmt::grant_option() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.grant_option)
  return _internal_grant_option();
}
inline void GrantStmt::set_grant_option(bool value) {
  _internal_set_grant_option(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantStmt.grant_option)
}
inline bool GrantStmt::_internal_grant_option() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.grant_option_;
}
inline void GrantStmt::_internal_set_grant_option(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.grant_option_ = value;
}

// .pg_query.RoleSpec grantor = 8 [json_name = "grantor"];
inline bool GrantStmt::has_grantor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.grantor_ != nullptr);
  return value;
}
inline void GrantStmt::clear_grantor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.grantor_ != nullptr) _impl_.grantor_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RoleSpec& GrantStmt::_internal_grantor() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RoleSpec* p = _impl_.grantor_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& GrantStmt::grantor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.grantor)
  return _internal_grantor();
}
inline void GrantStmt::unsafe_arena_set_allocated_grantor(::pg_query::RoleSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.grantor_);
  }
  _impl_.grantor_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.GrantStmt.grantor)
}
inline ::pg_query::RoleSpec* GrantStmt::release_grantor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* released = _impl_.grantor_;
  _impl_.grantor_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RoleSpec* GrantStmt::unsafe_arena_release_grantor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.GrantStmt.grantor)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* temp = _impl_.grantor_;
  _impl_.grantor_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* GrantStmt::_internal_mutable_grantor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.grantor_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    _impl_.grantor_ = reinterpret_cast<::pg_query::RoleSpec*>(p);
  }
  return _impl_.grantor_;
}
inline ::pg_query::RoleSpec* GrantStmt::mutable_grantor() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_grantor();
  // @@protoc_insertion_point(field_mutable:pg_query.GrantStmt.grantor)
  return _msg;
}
inline void GrantStmt::set_allocated_grantor(::pg_query::RoleSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RoleSpec*>(_impl_.grantor_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RoleSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.grantor_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.GrantStmt.grantor)
}

// .pg_query.DropBehavior behavior = 9 [json_name = "behavior"];
inline void GrantStmt::clear_behavior() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.behavior_ = 0;
}
inline ::pg_query::DropBehavior GrantStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantStmt.behavior)
  return _internal_behavior();
}
inline void GrantStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantStmt.behavior)
}
inline ::pg_query::DropBehavior GrantStmt::_internal_behavior() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::DropBehavior>(_impl_.behavior_);
}
inline void GrantStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.behavior_ = value;
}

// -------------------------------------------------------------------

// ObjectWithArgs

// repeated .pg_query.Node objname = 1 [json_name = "objname"];
inline int ObjectWithArgs::_internal_objname_size() const {
  return _internal_objname().size();
}
inline int ObjectWithArgs::objname_size() const {
  return _internal_objname_size();
}
inline void ObjectWithArgs::clear_objname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objname_.Clear();
}
inline ::pg_query::Node* ObjectWithArgs::mutable_objname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ObjectWithArgs.objname)
  return _internal_mutable_objname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ObjectWithArgs::mutable_objname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ObjectWithArgs.objname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_objname();
}
inline const ::pg_query::Node& ObjectWithArgs::objname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ObjectWithArgs.objname)
  return _internal_objname().Get(index);
}
inline ::pg_query::Node* ObjectWithArgs::add_objname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_objname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ObjectWithArgs.objname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ObjectWithArgs::objname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ObjectWithArgs.objname)
  return _internal_objname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ObjectWithArgs::_internal_objname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.objname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ObjectWithArgs::_internal_mutable_objname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.objname_;
}

// repeated .pg_query.Node objargs = 2 [json_name = "objargs"];
inline int ObjectWithArgs::_internal_objargs_size() const {
  return _internal_objargs().size();
}
inline int ObjectWithArgs::objargs_size() const {
  return _internal_objargs_size();
}
inline void ObjectWithArgs::clear_objargs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objargs_.Clear();
}
inline ::pg_query::Node* ObjectWithArgs::mutable_objargs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ObjectWithArgs.objargs)
  return _internal_mutable_objargs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ObjectWithArgs::mutable_objargs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ObjectWithArgs.objargs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_objargs();
}
inline const ::pg_query::Node& ObjectWithArgs::objargs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ObjectWithArgs.objargs)
  return _internal_objargs().Get(index);
}
inline ::pg_query::Node* ObjectWithArgs::add_objargs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_objargs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ObjectWithArgs.objargs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ObjectWithArgs::objargs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ObjectWithArgs.objargs)
  return _internal_objargs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ObjectWithArgs::_internal_objargs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.objargs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ObjectWithArgs::_internal_mutable_objargs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.objargs_;
}

// repeated .pg_query.Node objfuncargs = 3 [json_name = "objfuncargs"];
inline int ObjectWithArgs::_internal_objfuncargs_size() const {
  return _internal_objfuncargs().size();
}
inline int ObjectWithArgs::objfuncargs_size() const {
  return _internal_objfuncargs_size();
}
inline void ObjectWithArgs::clear_objfuncargs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objfuncargs_.Clear();
}
inline ::pg_query::Node* ObjectWithArgs::mutable_objfuncargs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ObjectWithArgs.objfuncargs)
  return _internal_mutable_objfuncargs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ObjectWithArgs::mutable_objfuncargs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ObjectWithArgs.objfuncargs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_objfuncargs();
}
inline const ::pg_query::Node& ObjectWithArgs::objfuncargs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ObjectWithArgs.objfuncargs)
  return _internal_objfuncargs().Get(index);
}
inline ::pg_query::Node* ObjectWithArgs::add_objfuncargs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_objfuncargs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ObjectWithArgs.objfuncargs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ObjectWithArgs::objfuncargs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ObjectWithArgs.objfuncargs)
  return _internal_objfuncargs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ObjectWithArgs::_internal_objfuncargs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.objfuncargs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ObjectWithArgs::_internal_mutable_objfuncargs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.objfuncargs_;
}

// bool args_unspecified = 4 [json_name = "args_unspecified"];
inline void ObjectWithArgs::clear_args_unspecified() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_unspecified_ = false;
}
inline bool ObjectWithArgs::args_unspecified() const {
  // @@protoc_insertion_point(field_get:pg_query.ObjectWithArgs.args_unspecified)
  return _internal_args_unspecified();
}
inline void ObjectWithArgs::set_args_unspecified(bool value) {
  _internal_set_args_unspecified(value);
  // @@protoc_insertion_point(field_set:pg_query.ObjectWithArgs.args_unspecified)
}
inline bool ObjectWithArgs::_internal_args_unspecified() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_unspecified_;
}
inline void ObjectWithArgs::_internal_set_args_unspecified(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.args_unspecified_ = value;
}

// -------------------------------------------------------------------

// AccessPriv

// string priv_name = 1 [json_name = "priv_name"];
inline void AccessPriv::clear_priv_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.priv_name_.ClearToEmpty();
}
inline const std::string& AccessPriv::priv_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AccessPriv.priv_name)
  return _internal_priv_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AccessPriv::set_priv_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.priv_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AccessPriv.priv_name)
}
inline std::string* AccessPriv::mutable_priv_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_priv_name();
  // @@protoc_insertion_point(field_mutable:pg_query.AccessPriv.priv_name)
  return _s;
}
inline const std::string& AccessPriv::_internal_priv_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.priv_name_.Get();
}
inline void AccessPriv::_internal_set_priv_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.priv_name_.Set(value, GetArena());
}
inline std::string* AccessPriv::_internal_mutable_priv_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.priv_name_.Mutable( GetArena());
}
inline std::string* AccessPriv::release_priv_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AccessPriv.priv_name)
  return _impl_.priv_name_.Release();
}
inline void AccessPriv::set_allocated_priv_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.priv_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.priv_name_.IsDefault()) {
          _impl_.priv_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_cols().size();
}
inline int AccessPriv::cols_size() const {
  return _internal_cols_size();
}
inline void AccessPriv::clear_cols() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cols_.Clear();
}
inline ::pg_query::Node* AccessPriv::mutable_cols(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AccessPriv.cols)
  return _internal_mutable_cols()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AccessPriv::mutable_cols()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AccessPriv.cols)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_cols();
}
inline const ::pg_query::Node& AccessPriv::cols(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AccessPriv.cols)
  return _internal_cols().Get(index);
}
inline ::pg_query::Node* AccessPriv::add_cols() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_cols()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AccessPriv.cols)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AccessPriv::cols() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AccessPriv.cols)
  return _internal_cols();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AccessPriv::_internal_cols() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cols_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AccessPriv::_internal_mutable_cols() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.cols_;
}

// -------------------------------------------------------------------

// GrantRoleStmt

// repeated .pg_query.Node granted_roles = 1 [json_name = "granted_roles"];
inline int GrantRoleStmt::_internal_granted_roles_size() const {
  return _internal_granted_roles().size();
}
inline int GrantRoleStmt::granted_roles_size() const {
  return _internal_granted_roles_size();
}
inline void GrantRoleStmt::clear_granted_roles() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.granted_roles_.Clear();
}
inline ::pg_query::Node* GrantRoleStmt::mutable_granted_roles(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.GrantRoleStmt.granted_roles)
  return _internal_mutable_granted_roles()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* GrantRoleStmt::mutable_granted_roles()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GrantRoleStmt.granted_roles)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_granted_roles();
}
inline const ::pg_query::Node& GrantRoleStmt::granted_roles(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.granted_roles)
  return _internal_granted_roles().Get(index);
}
inline ::pg_query::Node* GrantRoleStmt::add_granted_roles() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_granted_roles()->Add();
  // @@protoc_insertion_point(field_add:pg_query.GrantRoleStmt.granted_roles)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& GrantRoleStmt::granted_roles() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.GrantRoleStmt.granted_roles)
  return _internal_granted_roles();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
GrantRoleStmt::_internal_granted_roles() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.granted_roles_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
GrantRoleStmt::_internal_mutable_granted_roles() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.granted_roles_;
}

// repeated .pg_query.Node grantee_roles = 2 [json_name = "grantee_roles"];
inline int GrantRoleStmt::_internal_grantee_roles_size() const {
  return _internal_grantee_roles().size();
}
inline int GrantRoleStmt::grantee_roles_size() const {
  return _internal_grantee_roles_size();
}
inline void GrantRoleStmt::clear_grantee_roles() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.grantee_roles_.Clear();
}
inline ::pg_query::Node* GrantRoleStmt::mutable_grantee_roles(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.GrantRoleStmt.grantee_roles)
  return _internal_mutable_grantee_roles()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* GrantRoleStmt::mutable_grantee_roles()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GrantRoleStmt.grantee_roles)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_grantee_roles();
}
inline const ::pg_query::Node& GrantRoleStmt::grantee_roles(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.grantee_roles)
  return _internal_grantee_roles().Get(index);
}
inline ::pg_query::Node* GrantRoleStmt::add_grantee_roles() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_grantee_roles()->Add();
  // @@protoc_insertion_point(field_add:pg_query.GrantRoleStmt.grantee_roles)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& GrantRoleStmt::grantee_roles() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.GrantRoleStmt.grantee_roles)
  return _internal_grantee_roles();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
GrantRoleStmt::_internal_grantee_roles() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.grantee_roles_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
GrantRoleStmt::_internal_mutable_grantee_roles() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.grantee_roles_;
}

// bool is_grant = 3 [json_name = "is_grant"];
inline void GrantRoleStmt::clear_is_grant() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_grant_ = false;
}
inline bool GrantRoleStmt::is_grant() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.is_grant)
  return _internal_is_grant();
}
inline void GrantRoleStmt::set_is_grant(bool value) {
  _internal_set_is_grant(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantRoleStmt.is_grant)
}
inline bool GrantRoleStmt::_internal_is_grant() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_grant_;
}
inline void GrantRoleStmt::_internal_set_is_grant(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_grant_ = value;
}

// repeated .pg_query.Node opt = 4 [json_name = "opt"];
inline int GrantRoleStmt::_internal_opt_size() const {
  return _internal_opt().size();
}
inline int GrantRoleStmt::opt_size() const {
  return _internal_opt_size();
}
inline void GrantRoleStmt::clear_opt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opt_.Clear();
}
inline ::pg_query::Node* GrantRoleStmt::mutable_opt(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.GrantRoleStmt.opt)
  return _internal_mutable_opt()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* GrantRoleStmt::mutable_opt()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.GrantRoleStmt.opt)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_opt();
}
inline const ::pg_query::Node& GrantRoleStmt::opt(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.opt)
  return _internal_opt().Get(index);
}
inline ::pg_query::Node* GrantRoleStmt::add_opt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_opt()->Add();
  // @@protoc_insertion_point(field_add:pg_query.GrantRoleStmt.opt)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& GrantRoleStmt::opt() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.GrantRoleStmt.opt)
  return _internal_opt();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
GrantRoleStmt::_internal_opt() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opt_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
GrantRoleStmt::_internal_mutable_opt() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.opt_;
}

// .pg_query.RoleSpec grantor = 5 [json_name = "grantor"];
inline bool GrantRoleStmt::has_grantor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.grantor_ != nullptr);
  return value;
}
inline void GrantRoleStmt::clear_grantor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.grantor_ != nullptr) _impl_.grantor_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RoleSpec& GrantRoleStmt::_internal_grantor() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RoleSpec* p = _impl_.grantor_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& GrantRoleStmt::grantor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.grantor)
  return _internal_grantor();
}
inline void GrantRoleStmt::unsafe_arena_set_allocated_grantor(::pg_query::RoleSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.grantor_);
  }
  _impl_.grantor_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.GrantRoleStmt.grantor)
}
inline ::pg_query::RoleSpec* GrantRoleStmt::release_grantor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* released = _impl_.grantor_;
  _impl_.grantor_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RoleSpec* GrantRoleStmt::unsafe_arena_release_grantor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.GrantRoleStmt.grantor)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* temp = _impl_.grantor_;
  _impl_.grantor_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* GrantRoleStmt::_internal_mutable_grantor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.grantor_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    _impl_.grantor_ = reinterpret_cast<::pg_query::RoleSpec*>(p);
  }
  return _impl_.grantor_;
}
inline ::pg_query::RoleSpec* GrantRoleStmt::mutable_grantor() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_grantor();
  // @@protoc_insertion_point(field_mutable:pg_query.GrantRoleStmt.grantor)
  return _msg;
}
inline void GrantRoleStmt::set_allocated_grantor(::pg_query::RoleSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RoleSpec*>(_impl_.grantor_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RoleSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.grantor_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.GrantRoleStmt.grantor)
}

// .pg_query.DropBehavior behavior = 6 [json_name = "behavior"];
inline void GrantRoleStmt::clear_behavior() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.behavior_ = 0;
}
inline ::pg_query::DropBehavior GrantRoleStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.behavior)
  return _internal_behavior();
}
inline void GrantRoleStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.GrantRoleStmt.behavior)
}
inline ::pg_query::DropBehavior GrantRoleStmt::_internal_behavior() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::DropBehavior>(_impl_.behavior_);
}
inline void GrantRoleStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.behavior_ = value;
}

// -------------------------------------------------------------------

// AlterDefaultPrivilegesStmt

// repeated .pg_query.Node options = 1 [json_name = "options"];
inline int AlterDefaultPrivilegesStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int AlterDefaultPrivilegesStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterDefaultPrivilegesStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterDefaultPrivilegesStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDefaultPrivilegesStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterDefaultPrivilegesStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterDefaultPrivilegesStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterDefaultPrivilegesStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterDefaultPrivilegesStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterDefaultPrivilegesStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterDefaultPrivilegesStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterDefaultPrivilegesStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterDefaultPrivilegesStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterDefaultPrivilegesStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterDefaultPrivilegesStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// .pg_query.GrantStmt action = 2 [json_name = "action"];
inline bool AlterDefaultPrivilegesStmt::has_action() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.action_ != nullptr);
  return value;
}
inline void AlterDefaultPrivilegesStmt::clear_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.action_ != nullptr) _impl_.action_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::GrantStmt& AlterDefaultPrivilegesStmt::_internal_action() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::GrantStmt* p = _impl_.action_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::GrantStmt&>(::pg_query::_GrantStmt_default_instance_);
}
inline const ::pg_query::GrantStmt& AlterDefaultPrivilegesStmt::action() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterDefaultPrivilegesStmt.action)
  return _internal_action();
}
inline void AlterDefaultPrivilegesStmt::unsafe_arena_set_allocated_action(::pg_query::GrantStmt* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.action_);
  }
  _impl_.action_ = reinterpret_cast<::pg_query::GrantStmt*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterDefaultPrivilegesStmt.action)
}
inline ::pg_query::GrantStmt* AlterDefaultPrivilegesStmt::release_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::GrantStmt* released = _impl_.action_;
  _impl_.action_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::GrantStmt* AlterDefaultPrivilegesStmt::unsafe_arena_release_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterDefaultPrivilegesStmt.action)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::GrantStmt* temp = _impl_.action_;
  _impl_.action_ = nullptr;
  return temp;
}
inline ::pg_query::GrantStmt* AlterDefaultPrivilegesStmt::_internal_mutable_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.action_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::GrantStmt>(GetArena());
    _impl_.action_ = reinterpret_cast<::pg_query::GrantStmt*>(p);
  }
  return _impl_.action_;
}
inline ::pg_query::GrantStmt* AlterDefaultPrivilegesStmt::mutable_action() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::GrantStmt* _msg = _internal_mutable_action();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDefaultPrivilegesStmt.action)
  return _msg;
}
inline void AlterDefaultPrivilegesStmt::set_allocated_action(::pg_query::GrantStmt* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::GrantStmt*>(_impl_.action_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::GrantStmt*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.action_ = reinterpret_cast<::pg_query::GrantStmt*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDefaultPrivilegesStmt.action)
}

// -------------------------------------------------------------------

// CopyStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool CopyStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void CopyStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& CopyStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CopyStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.relation)
  return _internal_relation();
}
inline void CopyStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CopyStmt.relation)
}
inline ::pg_query::RangeVar* CopyStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* CopyStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CopyStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CopyStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* CopyStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.relation)
  return _msg;
}
inline void CopyStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CopyStmt.relation)
}

// .pg_query.Node query = 2 [json_name = "query"];
inline bool CopyStmt::has_query() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.query_ != nullptr);
  return value;
}
inline void CopyStmt::clear_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.query_ != nullptr) _impl_.query_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& CopyStmt::_internal_query() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CopyStmt::query() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.query)
  return _internal_query();
}
inline void CopyStmt::unsafe_arena_set_allocated_query(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.query_);
  }
  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CopyStmt.query)
}
inline ::pg_query::Node* CopyStmt::release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.query_;
  _impl_.query_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CopyStmt::unsafe_arena_release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CopyStmt.query)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.query_;
  _impl_.query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CopyStmt::_internal_mutable_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.query_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.query_;
}
inline ::pg_query::Node* CopyStmt::mutable_query() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_query();
  // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.query)
  return _msg;
}
inline void CopyStmt::set_allocated_query(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.query_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_attlist().size();
}
inline int CopyStmt::attlist_size() const {
  return _internal_attlist_size();
}
inline void CopyStmt::clear_attlist() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.attlist_.Clear();
}
inline ::pg_query::Node* CopyStmt::mutable_attlist(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.attlist)
  return _internal_mutable_attlist()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CopyStmt::mutable_attlist()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CopyStmt.attlist)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_attlist();
}
inline const ::pg_query::Node& CopyStmt::attlist(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.attlist)
  return _internal_attlist().Get(index);
}
inline ::pg_query::Node* CopyStmt::add_attlist() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_attlist()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CopyStmt.attlist)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CopyStmt::attlist() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CopyStmt.attlist)
  return _internal_attlist();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CopyStmt::_internal_attlist() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.attlist_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CopyStmt::_internal_mutable_attlist() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.attlist_;
}

// bool is_from = 4 [json_name = "is_from"];
inline void CopyStmt::clear_is_from() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_from_ = false;
}
inline bool CopyStmt::is_from() const {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.is_from)
  return _internal_is_from();
}
inline void CopyStmt::set_is_from(bool value) {
  _internal_set_is_from(value);
  // @@protoc_insertion_point(field_set:pg_query.CopyStmt.is_from)
}
inline bool CopyStmt::_internal_is_from() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_from_;
}
inline void CopyStmt::_internal_set_is_from(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_from_ = value;
}

// bool is_program = 5 [json_name = "is_program"];
inline void CopyStmt::clear_is_program() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_program_ = false;
}
inline bool CopyStmt::is_program() const {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.is_program)
  return _internal_is_program();
}
inline void CopyStmt::set_is_program(bool value) {
  _internal_set_is_program(value);
  // @@protoc_insertion_point(field_set:pg_query.CopyStmt.is_program)
}
inline bool CopyStmt::_internal_is_program() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_program_;
}
inline void CopyStmt::_internal_set_is_program(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_program_ = value;
}

// string filename = 6 [json_name = "filename"];
inline void CopyStmt::clear_filename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.filename_.ClearToEmpty();
}
inline const std::string& CopyStmt::filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.filename)
  return _internal_filename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CopyStmt::set_filename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.filename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CopyStmt.filename)
}
inline std::string* CopyStmt::mutable_filename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.filename)
  return _s;
}
inline const std::string& CopyStmt::_internal_filename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.filename_.Get();
}
inline void CopyStmt::_internal_set_filename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.filename_.Set(value, GetArena());
}
inline std::string* CopyStmt::_internal_mutable_filename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.filename_.Mutable( GetArena());
}
inline std::string* CopyStmt::release_filename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CopyStmt.filename)
  return _impl_.filename_.Release();
}
inline void CopyStmt::set_allocated_filename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.filename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.filename_.IsDefault()) {
          _impl_.filename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int CopyStmt::options_size() const {
  return _internal_options_size();
}
inline void CopyStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CopyStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CopyStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CopyStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CopyStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CopyStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CopyStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CopyStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CopyStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CopyStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CopyStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CopyStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// .pg_query.Node where_clause = 8 [json_name = "whereClause"];
inline bool CopyStmt::has_where_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.where_clause_ != nullptr);
  return value;
}
inline void CopyStmt::clear_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.where_clause_ != nullptr) _impl_.where_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& CopyStmt::_internal_where_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.where_clause_);
  }
  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CopyStmt.where_clause)
}
inline ::pg_query::Node* CopyStmt::release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CopyStmt::unsafe_arena_release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CopyStmt.where_clause)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CopyStmt::_internal_mutable_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.where_clause_;
}
inline ::pg_query::Node* CopyStmt::mutable_where_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_where_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.where_clause)
  return _msg;
}
inline void CopyStmt::set_allocated_where_clause(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.where_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CopyStmt.where_clause)
}

// -------------------------------------------------------------------

// VariableSetStmt

// .pg_query.VariableSetKind kind = 1 [json_name = "kind"];
inline void VariableSetStmt::clear_kind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.kind_ = 0;
}
inline ::pg_query::VariableSetKind VariableSetStmt::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.VariableSetStmt.kind)
  return _internal_kind();
}
inline void VariableSetStmt::set_kind(::pg_query::VariableSetKind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.VariableSetStmt.kind)
}
inline ::pg_query::VariableSetKind VariableSetStmt::_internal_kind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::VariableSetKind>(_impl_.kind_);
}
inline void VariableSetStmt::_internal_set_kind(::pg_query::VariableSetKind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.kind_ = value;
}

// string name = 2 [json_name = "name"];
inline void VariableSetStmt::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& VariableSetStmt::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.VariableSetStmt.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void VariableSetStmt::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.VariableSetStmt.name)
}
inline std::string* VariableSetStmt::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.VariableSetStmt.name)
  return _s;
}
inline const std::string& VariableSetStmt::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void VariableSetStmt::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* VariableSetStmt::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* VariableSetStmt::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.VariableSetStmt.name)
  return _impl_.name_.Release();
}
inline void VariableSetStmt::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_args().size();
}
inline int VariableSetStmt::args_size() const {
  return _internal_args_size();
}
inline void VariableSetStmt::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* VariableSetStmt::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.VariableSetStmt.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* VariableSetStmt::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.VariableSetStmt.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& VariableSetStmt::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.VariableSetStmt.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* VariableSetStmt::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.VariableSetStmt.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& VariableSetStmt::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.VariableSetStmt.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
VariableSetStmt::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
VariableSetStmt::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// bool is_local = 4 [json_name = "is_local"];
inline void VariableSetStmt::clear_is_local() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_local_ = false;
}
inline bool VariableSetStmt::is_local() const {
  // @@protoc_insertion_point(field_get:pg_query.VariableSetStmt.is_local)
  return _internal_is_local();
}
inline void VariableSetStmt::set_is_local(bool value) {
  _internal_set_is_local(value);
  // @@protoc_insertion_point(field_set:pg_query.VariableSetStmt.is_local)
}
inline bool VariableSetStmt::_internal_is_local() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_local_;
}
inline void VariableSetStmt::_internal_set_is_local(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_local_ = value;
}

// -------------------------------------------------------------------

// VariableShowStmt

// string name = 1 [json_name = "name"];
inline void VariableShowStmt::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& VariableShowStmt::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.VariableShowStmt.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void VariableShowStmt::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.VariableShowStmt.name)
}
inline std::string* VariableShowStmt::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.VariableShowStmt.name)
  return _s;
}
inline const std::string& VariableShowStmt::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void VariableShowStmt::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* VariableShowStmt::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* VariableShowStmt::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.VariableShowStmt.name)
  return _impl_.name_.Release();
}
inline void VariableShowStmt::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.VariableShowStmt.name)
}

// -------------------------------------------------------------------

// CreateStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool CreateStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void CreateStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& CreateStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CreateStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.relation)
  return _internal_relation();
}
inline void CreateStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateStmt.relation)
}
inline ::pg_query::RangeVar* CreateStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* CreateStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CreateStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* CreateStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.relation)
  return _msg;
}
inline void CreateStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@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 _internal_table_elts().size();
}
inline int CreateStmt::table_elts_size() const {
  return _internal_table_elts_size();
}
inline void CreateStmt::clear_table_elts() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.table_elts_.Clear();
}
inline ::pg_query::Node* CreateStmt::mutable_table_elts(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.table_elts)
  return _internal_mutable_table_elts()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateStmt::mutable_table_elts()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStmt.table_elts)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_table_elts();
}
inline const ::pg_query::Node& CreateStmt::table_elts(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.table_elts)
  return _internal_table_elts().Get(index);
}
inline ::pg_query::Node* CreateStmt::add_table_elts() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_table_elts()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateStmt.table_elts)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateStmt::table_elts() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateStmt.table_elts)
  return _internal_table_elts();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateStmt::_internal_table_elts() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.table_elts_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateStmt::_internal_mutable_table_elts() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.table_elts_;
}

// repeated .pg_query.Node inh_relations = 3 [json_name = "inhRelations"];
inline int CreateStmt::_internal_inh_relations_size() const {
  return _internal_inh_relations().size();
}
inline int CreateStmt::inh_relations_size() const {
  return _internal_inh_relations_size();
}
inline void CreateStmt::clear_inh_relations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inh_relations_.Clear();
}
inline ::pg_query::Node* CreateStmt::mutable_inh_relations(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.inh_relations)
  return _internal_mutable_inh_relations()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateStmt::mutable_inh_relations()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStmt.inh_relations)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_inh_relations();
}
inline const ::pg_query::Node& CreateStmt::inh_relations(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.inh_relations)
  return _internal_inh_relations().Get(index);
}
inline ::pg_query::Node* CreateStmt::add_inh_relations() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_inh_relations()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateStmt.inh_relations)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateStmt::inh_relations() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateStmt.inh_relations)
  return _internal_inh_relations();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateStmt::_internal_inh_relations() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inh_relations_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateStmt::_internal_mutable_inh_relations() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.inh_relations_;
}

// .pg_query.PartitionBoundSpec partbound = 4 [json_name = "partbound"];
inline bool CreateStmt::has_partbound() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.partbound_ != nullptr);
  return value;
}
inline void CreateStmt::clear_partbound() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.partbound_ != nullptr) _impl_.partbound_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::PartitionBoundSpec& CreateStmt::_internal_partbound() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::PartitionBoundSpec* p = _impl_.partbound_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::PartitionBoundSpec&>(::pg_query::_PartitionBoundSpec_default_instance_);
}
inline const ::pg_query::PartitionBoundSpec& CreateStmt::partbound() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.partbound)
  return _internal_partbound();
}
inline void CreateStmt::unsafe_arena_set_allocated_partbound(::pg_query::PartitionBoundSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.partbound_);
  }
  _impl_.partbound_ = reinterpret_cast<::pg_query::PartitionBoundSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateStmt.partbound)
}
inline ::pg_query::PartitionBoundSpec* CreateStmt::release_partbound() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::PartitionBoundSpec* released = _impl_.partbound_;
  _impl_.partbound_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::PartitionBoundSpec* CreateStmt::unsafe_arena_release_partbound() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateStmt.partbound)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::PartitionBoundSpec* temp = _impl_.partbound_;
  _impl_.partbound_ = nullptr;
  return temp;
}
inline ::pg_query::PartitionBoundSpec* CreateStmt::_internal_mutable_partbound() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.partbound_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::PartitionBoundSpec>(GetArena());
    _impl_.partbound_ = reinterpret_cast<::pg_query::PartitionBoundSpec*>(p);
  }
  return _impl_.partbound_;
}
inline ::pg_query::PartitionBoundSpec* CreateStmt::mutable_partbound() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PartitionBoundSpec* _msg = _internal_mutable_partbound();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.partbound)
  return _msg;
}
inline void CreateStmt::set_allocated_partbound(::pg_query::PartitionBoundSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::PartitionBoundSpec*>(_impl_.partbound_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::PartitionBoundSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.partbound_ = reinterpret_cast<::pg_query::PartitionBoundSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.partbound)
}

// .pg_query.PartitionSpec partspec = 5 [json_name = "partspec"];
inline bool CreateStmt::has_partspec() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.partspec_ != nullptr);
  return value;
}
inline void CreateStmt::clear_partspec() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.partspec_ != nullptr) _impl_.partspec_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::PartitionSpec& CreateStmt::_internal_partspec() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::PartitionSpec* p = _impl_.partspec_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::PartitionSpec&>(::pg_query::_PartitionSpec_default_instance_);
}
inline const ::pg_query::PartitionSpec& CreateStmt::partspec() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.partspec)
  return _internal_partspec();
}
inline void CreateStmt::unsafe_arena_set_allocated_partspec(::pg_query::PartitionSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.partspec_);
  }
  _impl_.partspec_ = reinterpret_cast<::pg_query::PartitionSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateStmt.partspec)
}
inline ::pg_query::PartitionSpec* CreateStmt::release_partspec() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::PartitionSpec* released = _impl_.partspec_;
  _impl_.partspec_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::PartitionSpec* CreateStmt::unsafe_arena_release_partspec() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateStmt.partspec)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::PartitionSpec* temp = _impl_.partspec_;
  _impl_.partspec_ = nullptr;
  return temp;
}
inline ::pg_query::PartitionSpec* CreateStmt::_internal_mutable_partspec() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.partspec_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::PartitionSpec>(GetArena());
    _impl_.partspec_ = reinterpret_cast<::pg_query::PartitionSpec*>(p);
  }
  return _impl_.partspec_;
}
inline ::pg_query::PartitionSpec* CreateStmt::mutable_partspec() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PartitionSpec* _msg = _internal_mutable_partspec();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.partspec)
  return _msg;
}
inline void CreateStmt::set_allocated_partspec(::pg_query::PartitionSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::PartitionSpec*>(_impl_.partspec_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::PartitionSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.partspec_ = reinterpret_cast<::pg_query::PartitionSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.partspec)
}

// .pg_query.TypeName of_typename = 6 [json_name = "ofTypename"];
inline bool CreateStmt::has_of_typename() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.of_typename_ != nullptr);
  return value;
}
inline void CreateStmt::clear_of_typename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.of_typename_ != nullptr) _impl_.of_typename_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::pg_query::TypeName& CreateStmt::_internal_of_typename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.of_typename_);
  }
  _impl_.of_typename_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateStmt.of_typename)
}
inline ::pg_query::TypeName* CreateStmt::release_of_typename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::TypeName* released = _impl_.of_typename_;
  _impl_.of_typename_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* CreateStmt::unsafe_arena_release_of_typename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateStmt.of_typename)

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::pg_query::TypeName* temp = _impl_.of_typename_;
  _impl_.of_typename_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateStmt::_internal_mutable_of_typename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.of_typename_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.of_typename_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.of_typename_;
}
inline ::pg_query::TypeName* CreateStmt::mutable_of_typename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_of_typename();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.of_typename)
  return _msg;
}
inline void CreateStmt::set_allocated_of_typename(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.of_typename_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }

  _impl_.of_typename_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@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 _internal_constraints().size();
}
inline int CreateStmt::constraints_size() const {
  return _internal_constraints_size();
}
inline void CreateStmt::clear_constraints() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.constraints_.Clear();
}
inline ::pg_query::Node* CreateStmt::mutable_constraints(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.constraints)
  return _internal_mutable_constraints()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateStmt::mutable_constraints()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStmt.constraints)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_constraints();
}
inline const ::pg_query::Node& CreateStmt::constraints(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.constraints)
  return _internal_constraints().Get(index);
}
inline ::pg_query::Node* CreateStmt::add_constraints() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_constraints()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateStmt.constraints)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateStmt::constraints() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateStmt.constraints)
  return _internal_constraints();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateStmt::_internal_constraints() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.constraints_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateStmt::_internal_mutable_constraints() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.constraints_;
}

// repeated .pg_query.Node options = 8 [json_name = "options"];
inline int CreateStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int CreateStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreateStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreateStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreateStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// .pg_query.OnCommitAction oncommit = 9 [json_name = "oncommit"];
inline void CreateStmt::clear_oncommit() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.oncommit_ = 0;
}
inline ::pg_query::OnCommitAction CreateStmt::oncommit() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.oncommit)
  return _internal_oncommit();
}
inline void CreateStmt::set_oncommit(::pg_query::OnCommitAction value) {
  _internal_set_oncommit(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateStmt.oncommit)
}
inline ::pg_query::OnCommitAction CreateStmt::_internal_oncommit() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::OnCommitAction>(_impl_.oncommit_);
}
inline void CreateStmt::_internal_set_oncommit(::pg_query::OnCommitAction value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.oncommit_ = value;
}

// string tablespacename = 10 [json_name = "tablespacename"];
inline void CreateStmt::clear_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tablespacename_.ClearToEmpty();
}
inline const std::string& CreateStmt::tablespacename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.tablespacename)
  return _internal_tablespacename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateStmt::set_tablespacename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.tablespacename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateStmt.tablespacename)
}
inline std::string* CreateStmt::mutable_tablespacename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_tablespacename();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.tablespacename)
  return _s;
}
inline const std::string& CreateStmt::_internal_tablespacename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.tablespacename_.Get();
}
inline void CreateStmt::_internal_set_tablespacename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.tablespacename_.Set(value, GetArena());
}
inline std::string* CreateStmt::_internal_mutable_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.tablespacename_.Mutable( GetArena());
}
inline std::string* CreateStmt::release_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateStmt.tablespacename)
  return _impl_.tablespacename_.Release();
}
inline void CreateStmt::set_allocated_tablespacename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tablespacename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.tablespacename_.IsDefault()) {
          _impl_.tablespacename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.tablespacename)
}

// string access_method = 11 [json_name = "accessMethod"];
inline void CreateStmt::clear_access_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.access_method_.ClearToEmpty();
}
inline const std::string& CreateStmt::access_method() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStmt.access_method)
  return _internal_access_method();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateStmt::set_access_method(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.access_method_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateStmt.access_method)
}
inline std::string* CreateStmt::mutable_access_method() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_access_method();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.access_method)
  return _s;
}
inline const std::string& CreateStmt::_internal_access_method() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.access_method_.Get();
}
inline void CreateStmt::_internal_set_access_method(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.access_method_.Set(value, GetArena());
}
inline std::string* CreateStmt::_internal_mutable_access_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.access_method_.Mutable( GetArena());
}
inline std::string* CreateStmt::release_access_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateStmt.access_method)
  return _impl_.access_method_.Release();
}
inline void CreateStmt::set_allocated_access_method(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.access_method_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.access_method_.IsDefault()) {
          _impl_.access_method_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.if_not_exists_ = false;
}
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::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateStmt.if_not_exists)
}
inline bool CreateStmt::_internal_if_not_exists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.if_not_exists_;
}
inline void CreateStmt::_internal_set_if_not_exists(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.if_not_exists_ = value;
}

// -------------------------------------------------------------------

// Constraint

// .pg_query.ConstrType contype = 1 [json_name = "contype"];
inline void Constraint::clear_contype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.contype_ = 0;
}
inline ::pg_query::ConstrType Constraint::contype() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.contype)
  return _internal_contype();
}
inline void Constraint::set_contype(::pg_query::ConstrType value) {
  _internal_set_contype(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.contype)
}
inline ::pg_query::ConstrType Constraint::_internal_contype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ConstrType>(_impl_.contype_);
}
inline void Constraint::_internal_set_contype(::pg_query::ConstrType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.contype_ = value;
}

// string conname = 2 [json_name = "conname"];
inline void Constraint::clear_conname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conname_.ClearToEmpty();
}
inline const std::string& Constraint::conname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.conname)
  return _internal_conname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Constraint::set_conname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.Constraint.conname)
}
inline std::string* Constraint::mutable_conname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_conname();
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.conname)
  return _s;
}
inline const std::string& Constraint::_internal_conname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.conname_.Get();
}
inline void Constraint::_internal_set_conname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conname_.Set(value, GetArena());
}
inline std::string* Constraint::_internal_mutable_conname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.conname_.Mutable( GetArena());
}
inline std::string* Constraint::release_conname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Constraint.conname)
  return _impl_.conname_.Release();
}
inline void Constraint::set_allocated_conname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.conname_.IsDefault()) {
          _impl_.conname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.conname)
}

// bool deferrable = 3 [json_name = "deferrable"];
inline void Constraint::clear_deferrable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.deferrable_ = false;
}
inline bool Constraint::deferrable() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.deferrable)
  return _internal_deferrable();
}
inline void Constraint::set_deferrable(bool value) {
  _internal_set_deferrable(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.deferrable)
}
inline bool Constraint::_internal_deferrable() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.deferrable_;
}
inline void Constraint::_internal_set_deferrable(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.deferrable_ = value;
}

// bool initdeferred = 4 [json_name = "initdeferred"];
inline void Constraint::clear_initdeferred() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.initdeferred_ = false;
}
inline bool Constraint::initdeferred() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.initdeferred)
  return _internal_initdeferred();
}
inline void Constraint::set_initdeferred(bool value) {
  _internal_set_initdeferred(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.initdeferred)
}
inline bool Constraint::_internal_initdeferred() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.initdeferred_;
}
inline void Constraint::_internal_set_initdeferred(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.initdeferred_ = value;
}

// int32 location = 5 [json_name = "location"];
inline void Constraint::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t Constraint::location() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.location)
  return _internal_location();
}
inline void Constraint::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.location)
}
inline ::int32_t Constraint::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void Constraint::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// bool is_no_inherit = 6 [json_name = "is_no_inherit"];
inline void Constraint::clear_is_no_inherit() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_no_inherit_ = false;
}
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::set_is_no_inherit(bool value) {
  _internal_set_is_no_inherit(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.is_no_inherit)
}
inline bool Constraint::_internal_is_no_inherit() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_no_inherit_;
}
inline void Constraint::_internal_set_is_no_inherit(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_no_inherit_ = value;
}

// .pg_query.Node raw_expr = 7 [json_name = "raw_expr"];
inline bool Constraint::has_raw_expr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.raw_expr_ != nullptr);
  return value;
}
inline void Constraint::clear_raw_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.raw_expr_ != nullptr) _impl_.raw_expr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& Constraint::_internal_raw_expr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.raw_expr_);
  }
  _impl_.raw_expr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Constraint.raw_expr)
}
inline ::pg_query::Node* Constraint::release_raw_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.raw_expr_;
  _impl_.raw_expr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* Constraint::unsafe_arena_release_raw_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Constraint.raw_expr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.raw_expr_;
  _impl_.raw_expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Constraint::_internal_mutable_raw_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.raw_expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.raw_expr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.raw_expr_;
}
inline ::pg_query::Node* Constraint::mutable_raw_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_raw_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.raw_expr)
  return _msg;
}
inline void Constraint::set_allocated_raw_expr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.raw_expr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.raw_expr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cooked_expr_.ClearToEmpty();
}
inline const std::string& Constraint::cooked_expr() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.cooked_expr)
  return _internal_cooked_expr();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Constraint::set_cooked_expr(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cooked_expr_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.Constraint.cooked_expr)
}
inline std::string* Constraint::mutable_cooked_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_cooked_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.cooked_expr)
  return _s;
}
inline const std::string& Constraint::_internal_cooked_expr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cooked_expr_.Get();
}
inline void Constraint::_internal_set_cooked_expr(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cooked_expr_.Set(value, GetArena());
}
inline std::string* Constraint::_internal_mutable_cooked_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.cooked_expr_.Mutable( GetArena());
}
inline std::string* Constraint::release_cooked_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Constraint.cooked_expr)
  return _impl_.cooked_expr_.Release();
}
inline void Constraint::set_allocated_cooked_expr(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cooked_expr_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.cooked_expr_.IsDefault()) {
          _impl_.cooked_expr_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.generated_when_.ClearToEmpty();
}
inline const std::string& Constraint::generated_when() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.generated_when)
  return _internal_generated_when();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Constraint::set_generated_when(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.generated_when_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.Constraint.generated_when)
}
inline std::string* Constraint::mutable_generated_when() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_generated_when();
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.generated_when)
  return _s;
}
inline const std::string& Constraint::_internal_generated_when() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.generated_when_.Get();
}
inline void Constraint::_internal_set_generated_when(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.generated_when_.Set(value, GetArena());
}
inline std::string* Constraint::_internal_mutable_generated_when() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.generated_when_.Mutable( GetArena());
}
inline std::string* Constraint::release_generated_when() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Constraint.generated_when)
  return _impl_.generated_when_.Release();
}
inline void Constraint::set_allocated_generated_when(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.generated_when_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.generated_when_.IsDefault()) {
          _impl_.generated_when_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.generated_when)
}

// bool nulls_not_distinct = 10 [json_name = "nulls_not_distinct"];
inline void Constraint::clear_nulls_not_distinct() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.nulls_not_distinct_ = false;
}
inline bool Constraint::nulls_not_distinct() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.nulls_not_distinct)
  return _internal_nulls_not_distinct();
}
inline void Constraint::set_nulls_not_distinct(bool value) {
  _internal_set_nulls_not_distinct(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.nulls_not_distinct)
}
inline bool Constraint::_internal_nulls_not_distinct() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.nulls_not_distinct_;
}
inline void Constraint::_internal_set_nulls_not_distinct(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.nulls_not_distinct_ = value;
}

// repeated .pg_query.Node keys = 11 [json_name = "keys"];
inline int Constraint::_internal_keys_size() const {
  return _internal_keys().size();
}
inline int Constraint::keys_size() const {
  return _internal_keys_size();
}
inline void Constraint::clear_keys() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.keys_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_keys(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.keys)
  return _internal_mutable_keys()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Constraint::mutable_keys()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.keys)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_keys();
}
inline const ::pg_query::Node& Constraint::keys(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.keys)
  return _internal_keys().Get(index);
}
inline ::pg_query::Node* Constraint::add_keys() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_keys()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Constraint.keys)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Constraint::keys() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.keys)
  return _internal_keys();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Constraint::_internal_keys() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.keys_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Constraint::_internal_mutable_keys() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.keys_;
}

// repeated .pg_query.Node including = 12 [json_name = "including"];
inline int Constraint::_internal_including_size() const {
  return _internal_including().size();
}
inline int Constraint::including_size() const {
  return _internal_including_size();
}
inline void Constraint::clear_including() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.including_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_including(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.including)
  return _internal_mutable_including()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Constraint::mutable_including()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.including)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_including();
}
inline const ::pg_query::Node& Constraint::including(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.including)
  return _internal_including().Get(index);
}
inline ::pg_query::Node* Constraint::add_including() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_including()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Constraint.including)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Constraint::including() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.including)
  return _internal_including();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Constraint::_internal_including() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.including_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Constraint::_internal_mutable_including() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.including_;
}

// repeated .pg_query.Node exclusions = 13 [json_name = "exclusions"];
inline int Constraint::_internal_exclusions_size() const {
  return _internal_exclusions().size();
}
inline int Constraint::exclusions_size() const {
  return _internal_exclusions_size();
}
inline void Constraint::clear_exclusions() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.exclusions_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_exclusions(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.exclusions)
  return _internal_mutable_exclusions()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Constraint::mutable_exclusions()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.exclusions)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_exclusions();
}
inline const ::pg_query::Node& Constraint::exclusions(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.exclusions)
  return _internal_exclusions().Get(index);
}
inline ::pg_query::Node* Constraint::add_exclusions() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_exclusions()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Constraint.exclusions)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Constraint::exclusions() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.exclusions)
  return _internal_exclusions();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Constraint::_internal_exclusions() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.exclusions_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Constraint::_internal_mutable_exclusions() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.exclusions_;
}

// repeated .pg_query.Node options = 14 [json_name = "options"];
inline int Constraint::_internal_options_size() const {
  return _internal_options().size();
}
inline int Constraint::options_size() const {
  return _internal_options_size();
}
inline void Constraint::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Constraint::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& Constraint::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* Constraint::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Constraint.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Constraint::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Constraint::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Constraint::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// string indexname = 15 [json_name = "indexname"];
inline void Constraint::clear_indexname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indexname_.ClearToEmpty();
}
inline const std::string& Constraint::indexname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.indexname)
  return _internal_indexname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Constraint::set_indexname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.indexname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.Constraint.indexname)
}
inline std::string* Constraint::mutable_indexname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_indexname();
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.indexname)
  return _s;
}
inline const std::string& Constraint::_internal_indexname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.indexname_.Get();
}
inline void Constraint::_internal_set_indexname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.indexname_.Set(value, GetArena());
}
inline std::string* Constraint::_internal_mutable_indexname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.indexname_.Mutable( GetArena());
}
inline std::string* Constraint::release_indexname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Constraint.indexname)
  return _impl_.indexname_.Release();
}
inline void Constraint::set_allocated_indexname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indexname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.indexname_.IsDefault()) {
          _impl_.indexname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.indexname)
}

// string indexspace = 16 [json_name = "indexspace"];
inline void Constraint::clear_indexspace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indexspace_.ClearToEmpty();
}
inline const std::string& Constraint::indexspace() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.indexspace)
  return _internal_indexspace();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Constraint::set_indexspace(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.indexspace_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.Constraint.indexspace)
}
inline std::string* Constraint::mutable_indexspace() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_indexspace();
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.indexspace)
  return _s;
}
inline const std::string& Constraint::_internal_indexspace() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.indexspace_.Get();
}
inline void Constraint::_internal_set_indexspace(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.indexspace_.Set(value, GetArena());
}
inline std::string* Constraint::_internal_mutable_indexspace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.indexspace_.Mutable( GetArena());
}
inline std::string* Constraint::release_indexspace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Constraint.indexspace)
  return _impl_.indexspace_.Release();
}
inline void Constraint::set_allocated_indexspace(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indexspace_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.indexspace_.IsDefault()) {
          _impl_.indexspace_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.indexspace)
}

// bool reset_default_tblspc = 17 [json_name = "reset_default_tblspc"];
inline void Constraint::clear_reset_default_tblspc() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.reset_default_tblspc_ = false;
}
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::set_reset_default_tblspc(bool value) {
  _internal_set_reset_default_tblspc(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.reset_default_tblspc)
}
inline bool Constraint::_internal_reset_default_tblspc() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.reset_default_tblspc_;
}
inline void Constraint::_internal_set_reset_default_tblspc(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.reset_default_tblspc_ = value;
}

// string access_method = 18 [json_name = "access_method"];
inline void Constraint::clear_access_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.access_method_.ClearToEmpty();
}
inline const std::string& Constraint::access_method() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.access_method)
  return _internal_access_method();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Constraint::set_access_method(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.access_method_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.Constraint.access_method)
}
inline std::string* Constraint::mutable_access_method() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_access_method();
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.access_method)
  return _s;
}
inline const std::string& Constraint::_internal_access_method() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.access_method_.Get();
}
inline void Constraint::_internal_set_access_method(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.access_method_.Set(value, GetArena());
}
inline std::string* Constraint::_internal_mutable_access_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.access_method_.Mutable( GetArena());
}
inline std::string* Constraint::release_access_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Constraint.access_method)
  return _impl_.access_method_.Release();
}
inline void Constraint::set_allocated_access_method(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.access_method_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.access_method_.IsDefault()) {
          _impl_.access_method_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.access_method)
}

// .pg_query.Node where_clause = 19 [json_name = "where_clause"];
inline bool Constraint::has_where_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.where_clause_ != nullptr);
  return value;
}
inline void Constraint::clear_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.where_clause_ != nullptr) _impl_.where_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& Constraint::_internal_where_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.where_clause_);
  }
  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Constraint.where_clause)
}
inline ::pg_query::Node* Constraint::release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* Constraint::unsafe_arena_release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Constraint.where_clause)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* Constraint::_internal_mutable_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.where_clause_;
}
inline ::pg_query::Node* Constraint::mutable_where_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_where_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.where_clause)
  return _msg;
}
inline void Constraint::set_allocated_where_clause(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.where_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.where_clause)
}

// .pg_query.RangeVar pktable = 20 [json_name = "pktable"];
inline bool Constraint::has_pktable() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pktable_ != nullptr);
  return value;
}
inline void Constraint::clear_pktable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.pktable_ != nullptr) _impl_.pktable_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::RangeVar& Constraint::_internal_pktable() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.pktable_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& Constraint::pktable() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.pktable)
  return _internal_pktable();
}
inline void Constraint::unsafe_arena_set_allocated_pktable(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.pktable_);
  }
  _impl_.pktable_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Constraint.pktable)
}
inline ::pg_query::RangeVar* Constraint::release_pktable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::RangeVar* released = _impl_.pktable_;
  _impl_.pktable_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* Constraint::unsafe_arena_release_pktable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Constraint.pktable)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::RangeVar* temp = _impl_.pktable_;
  _impl_.pktable_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* Constraint::_internal_mutable_pktable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.pktable_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.pktable_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.pktable_;
}
inline ::pg_query::RangeVar* Constraint::mutable_pktable() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_pktable();
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.pktable)
  return _msg;
}
inline void Constraint::set_allocated_pktable(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.pktable_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.pktable_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.pktable)
}

// repeated .pg_query.Node fk_attrs = 21 [json_name = "fk_attrs"];
inline int Constraint::_internal_fk_attrs_size() const {
  return _internal_fk_attrs().size();
}
inline int Constraint::fk_attrs_size() const {
  return _internal_fk_attrs_size();
}
inline void Constraint::clear_fk_attrs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fk_attrs_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_fk_attrs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.fk_attrs)
  return _internal_mutable_fk_attrs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Constraint::mutable_fk_attrs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.fk_attrs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_fk_attrs();
}
inline const ::pg_query::Node& Constraint::fk_attrs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_attrs)
  return _internal_fk_attrs().Get(index);
}
inline ::pg_query::Node* Constraint::add_fk_attrs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_fk_attrs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Constraint.fk_attrs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Constraint::fk_attrs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.fk_attrs)
  return _internal_fk_attrs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Constraint::_internal_fk_attrs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fk_attrs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Constraint::_internal_mutable_fk_attrs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.fk_attrs_;
}

// repeated .pg_query.Node pk_attrs = 22 [json_name = "pk_attrs"];
inline int Constraint::_internal_pk_attrs_size() const {
  return _internal_pk_attrs().size();
}
inline int Constraint::pk_attrs_size() const {
  return _internal_pk_attrs_size();
}
inline void Constraint::clear_pk_attrs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.pk_attrs_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_pk_attrs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.pk_attrs)
  return _internal_mutable_pk_attrs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Constraint::mutable_pk_attrs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.pk_attrs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_pk_attrs();
}
inline const ::pg_query::Node& Constraint::pk_attrs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.pk_attrs)
  return _internal_pk_attrs().Get(index);
}
inline ::pg_query::Node* Constraint::add_pk_attrs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_pk_attrs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Constraint.pk_attrs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Constraint::pk_attrs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.pk_attrs)
  return _internal_pk_attrs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Constraint::_internal_pk_attrs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.pk_attrs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Constraint::_internal_mutable_pk_attrs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.pk_attrs_;
}

// string fk_matchtype = 23 [json_name = "fk_matchtype"];
inline void Constraint::clear_fk_matchtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fk_matchtype_.ClearToEmpty();
}
inline const std::string& Constraint::fk_matchtype() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_matchtype)
  return _internal_fk_matchtype();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Constraint::set_fk_matchtype(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fk_matchtype_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.Constraint.fk_matchtype)
}
inline std::string* Constraint::mutable_fk_matchtype() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_fk_matchtype();
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.fk_matchtype)
  return _s;
}
inline const std::string& Constraint::_internal_fk_matchtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fk_matchtype_.Get();
}
inline void Constraint::_internal_set_fk_matchtype(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fk_matchtype_.Set(value, GetArena());
}
inline std::string* Constraint::_internal_mutable_fk_matchtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.fk_matchtype_.Mutable( GetArena());
}
inline std::string* Constraint::release_fk_matchtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Constraint.fk_matchtype)
  return _impl_.fk_matchtype_.Release();
}
inline void Constraint::set_allocated_fk_matchtype(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fk_matchtype_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.fk_matchtype_.IsDefault()) {
          _impl_.fk_matchtype_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.fk_matchtype)
}

// string fk_upd_action = 24 [json_name = "fk_upd_action"];
inline void Constraint::clear_fk_upd_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fk_upd_action_.ClearToEmpty();
}
inline const std::string& Constraint::fk_upd_action() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_upd_action)
  return _internal_fk_upd_action();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Constraint::set_fk_upd_action(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fk_upd_action_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.Constraint.fk_upd_action)
}
inline std::string* Constraint::mutable_fk_upd_action() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_fk_upd_action();
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.fk_upd_action)
  return _s;
}
inline const std::string& Constraint::_internal_fk_upd_action() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fk_upd_action_.Get();
}
inline void Constraint::_internal_set_fk_upd_action(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fk_upd_action_.Set(value, GetArena());
}
inline std::string* Constraint::_internal_mutable_fk_upd_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.fk_upd_action_.Mutable( GetArena());
}
inline std::string* Constraint::release_fk_upd_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Constraint.fk_upd_action)
  return _impl_.fk_upd_action_.Release();
}
inline void Constraint::set_allocated_fk_upd_action(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fk_upd_action_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.fk_upd_action_.IsDefault()) {
          _impl_.fk_upd_action_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.fk_upd_action)
}

// string fk_del_action = 25 [json_name = "fk_del_action"];
inline void Constraint::clear_fk_del_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fk_del_action_.ClearToEmpty();
}
inline const std::string& Constraint::fk_del_action() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_del_action)
  return _internal_fk_del_action();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Constraint::set_fk_del_action(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fk_del_action_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.Constraint.fk_del_action)
}
inline std::string* Constraint::mutable_fk_del_action() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_fk_del_action();
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.fk_del_action)
  return _s;
}
inline const std::string& Constraint::_internal_fk_del_action() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fk_del_action_.Get();
}
inline void Constraint::_internal_set_fk_del_action(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fk_del_action_.Set(value, GetArena());
}
inline std::string* Constraint::_internal_mutable_fk_del_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.fk_del_action_.Mutable( GetArena());
}
inline std::string* Constraint::release_fk_del_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.Constraint.fk_del_action)
  return _impl_.fk_del_action_.Release();
}
inline void Constraint::set_allocated_fk_del_action(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fk_del_action_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.fk_del_action_.IsDefault()) {
          _impl_.fk_del_action_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.fk_del_action)
}

// repeated .pg_query.Node fk_del_set_cols = 26 [json_name = "fk_del_set_cols"];
inline int Constraint::_internal_fk_del_set_cols_size() const {
  return _internal_fk_del_set_cols().size();
}
inline int Constraint::fk_del_set_cols_size() const {
  return _internal_fk_del_set_cols_size();
}
inline void Constraint::clear_fk_del_set_cols() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fk_del_set_cols_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_fk_del_set_cols(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.fk_del_set_cols)
  return _internal_mutable_fk_del_set_cols()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Constraint::mutable_fk_del_set_cols()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.fk_del_set_cols)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_fk_del_set_cols();
}
inline const ::pg_query::Node& Constraint::fk_del_set_cols(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_del_set_cols)
  return _internal_fk_del_set_cols().Get(index);
}
inline ::pg_query::Node* Constraint::add_fk_del_set_cols() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_fk_del_set_cols()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Constraint.fk_del_set_cols)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Constraint::fk_del_set_cols() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.fk_del_set_cols)
  return _internal_fk_del_set_cols();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Constraint::_internal_fk_del_set_cols() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fk_del_set_cols_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Constraint::_internal_mutable_fk_del_set_cols() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.fk_del_set_cols_;
}

// repeated .pg_query.Node old_conpfeqop = 27 [json_name = "old_conpfeqop"];
inline int Constraint::_internal_old_conpfeqop_size() const {
  return _internal_old_conpfeqop().size();
}
inline int Constraint::old_conpfeqop_size() const {
  return _internal_old_conpfeqop_size();
}
inline void Constraint::clear_old_conpfeqop() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.old_conpfeqop_.Clear();
}
inline ::pg_query::Node* Constraint::mutable_old_conpfeqop(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.Constraint.old_conpfeqop)
  return _internal_mutable_old_conpfeqop()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* Constraint::mutable_old_conpfeqop()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.old_conpfeqop)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_old_conpfeqop();
}
inline const ::pg_query::Node& Constraint::old_conpfeqop(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.old_conpfeqop)
  return _internal_old_conpfeqop().Get(index);
}
inline ::pg_query::Node* Constraint::add_old_conpfeqop() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_old_conpfeqop()->Add();
  // @@protoc_insertion_point(field_add:pg_query.Constraint.old_conpfeqop)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& Constraint::old_conpfeqop() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.Constraint.old_conpfeqop)
  return _internal_old_conpfeqop();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
Constraint::_internal_old_conpfeqop() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.old_conpfeqop_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
Constraint::_internal_mutable_old_conpfeqop() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.old_conpfeqop_;
}

// uint32 old_pktable_oid = 28 [json_name = "old_pktable_oid"];
inline void Constraint::clear_old_pktable_oid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.old_pktable_oid_ = 0u;
}
inline ::uint32_t Constraint::old_pktable_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.old_pktable_oid)
  return _internal_old_pktable_oid();
}
inline void Constraint::set_old_pktable_oid(::uint32_t value) {
  _internal_set_old_pktable_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.old_pktable_oid)
}
inline ::uint32_t Constraint::_internal_old_pktable_oid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.old_pktable_oid_;
}
inline void Constraint::_internal_set_old_pktable_oid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.old_pktable_oid_ = value;
}

// bool skip_validation = 29 [json_name = "skip_validation"];
inline void Constraint::clear_skip_validation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.skip_validation_ = false;
}
inline bool Constraint::skip_validation() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.skip_validation)
  return _internal_skip_validation();
}
inline void Constraint::set_skip_validation(bool value) {
  _internal_set_skip_validation(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.skip_validation)
}
inline bool Constraint::_internal_skip_validation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.skip_validation_;
}
inline void Constraint::_internal_set_skip_validation(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.skip_validation_ = value;
}

// bool initially_valid = 30 [json_name = "initially_valid"];
inline void Constraint::clear_initially_valid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.initially_valid_ = false;
}
inline bool Constraint::initially_valid() const {
  // @@protoc_insertion_point(field_get:pg_query.Constraint.initially_valid)
  return _internal_initially_valid();
}
inline void Constraint::set_initially_valid(bool value) {
  _internal_set_initially_valid(value);
  // @@protoc_insertion_point(field_set:pg_query.Constraint.initially_valid)
}
inline bool Constraint::_internal_initially_valid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.initially_valid_;
}
inline void Constraint::_internal_set_initially_valid(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.initially_valid_ = value;
}

// -------------------------------------------------------------------

// CreateTableSpaceStmt

// string tablespacename = 1 [json_name = "tablespacename"];
inline void CreateTableSpaceStmt::clear_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tablespacename_.ClearToEmpty();
}
inline const std::string& CreateTableSpaceStmt::tablespacename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableSpaceStmt.tablespacename)
  return _internal_tablespacename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateTableSpaceStmt::set_tablespacename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.tablespacename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateTableSpaceStmt.tablespacename)
}
inline std::string* CreateTableSpaceStmt::mutable_tablespacename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_tablespacename();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTableSpaceStmt.tablespacename)
  return _s;
}
inline const std::string& CreateTableSpaceStmt::_internal_tablespacename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.tablespacename_.Get();
}
inline void CreateTableSpaceStmt::_internal_set_tablespacename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.tablespacename_.Set(value, GetArena());
}
inline std::string* CreateTableSpaceStmt::_internal_mutable_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.tablespacename_.Mutable( GetArena());
}
inline std::string* CreateTableSpaceStmt::release_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTableSpaceStmt.tablespacename)
  return _impl_.tablespacename_.Release();
}
inline void CreateTableSpaceStmt::set_allocated_tablespacename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tablespacename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.tablespacename_.IsDefault()) {
          _impl_.tablespacename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTableSpaceStmt.tablespacename)
}

// .pg_query.RoleSpec owner = 2 [json_name = "owner"];
inline bool CreateTableSpaceStmt::has_owner() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.owner_ != nullptr);
  return value;
}
inline void CreateTableSpaceStmt::clear_owner() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.owner_ != nullptr) _impl_.owner_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RoleSpec& CreateTableSpaceStmt::_internal_owner() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RoleSpec* p = _impl_.owner_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& CreateTableSpaceStmt::owner() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableSpaceStmt.owner)
  return _internal_owner();
}
inline void CreateTableSpaceStmt::unsafe_arena_set_allocated_owner(::pg_query::RoleSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.owner_);
  }
  _impl_.owner_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTableSpaceStmt.owner)
}
inline ::pg_query::RoleSpec* CreateTableSpaceStmt::release_owner() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* released = _impl_.owner_;
  _impl_.owner_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RoleSpec* CreateTableSpaceStmt::unsafe_arena_release_owner() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTableSpaceStmt.owner)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* temp = _impl_.owner_;
  _impl_.owner_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* CreateTableSpaceStmt::_internal_mutable_owner() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.owner_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    _impl_.owner_ = reinterpret_cast<::pg_query::RoleSpec*>(p);
  }
  return _impl_.owner_;
}
inline ::pg_query::RoleSpec* CreateTableSpaceStmt::mutable_owner() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_owner();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTableSpaceStmt.owner)
  return _msg;
}
inline void CreateTableSpaceStmt::set_allocated_owner(::pg_query::RoleSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RoleSpec*>(_impl_.owner_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RoleSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.owner_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTableSpaceStmt.owner)
}

// string location = 3 [json_name = "location"];
inline void CreateTableSpaceStmt::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_.ClearToEmpty();
}
inline const std::string& CreateTableSpaceStmt::location() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableSpaceStmt.location)
  return _internal_location();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateTableSpaceStmt::set_location(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateTableSpaceStmt.location)
}
inline std::string* CreateTableSpaceStmt::mutable_location() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_location();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTableSpaceStmt.location)
  return _s;
}
inline const std::string& CreateTableSpaceStmt::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_.Get();
}
inline void CreateTableSpaceStmt::_internal_set_location(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_.Set(value, GetArena());
}
inline std::string* CreateTableSpaceStmt::_internal_mutable_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.location_.Mutable( GetArena());
}
inline std::string* CreateTableSpaceStmt::release_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTableSpaceStmt.location)
  return _impl_.location_.Release();
}
inline void CreateTableSpaceStmt::set_allocated_location(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.location_.IsDefault()) {
          _impl_.location_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int CreateTableSpaceStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateTableSpaceStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreateTableSpaceStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTableSpaceStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateTableSpaceStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTableSpaceStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreateTableSpaceStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableSpaceStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreateTableSpaceStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateTableSpaceStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateTableSpaceStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateTableSpaceStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateTableSpaceStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateTableSpaceStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// DropTableSpaceStmt

// string tablespacename = 1 [json_name = "tablespacename"];
inline void DropTableSpaceStmt::clear_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tablespacename_.ClearToEmpty();
}
inline const std::string& DropTableSpaceStmt::tablespacename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DropTableSpaceStmt.tablespacename)
  return _internal_tablespacename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DropTableSpaceStmt::set_tablespacename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.tablespacename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.DropTableSpaceStmt.tablespacename)
}
inline std::string* DropTableSpaceStmt::mutable_tablespacename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_tablespacename();
  // @@protoc_insertion_point(field_mutable:pg_query.DropTableSpaceStmt.tablespacename)
  return _s;
}
inline const std::string& DropTableSpaceStmt::_internal_tablespacename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.tablespacename_.Get();
}
inline void DropTableSpaceStmt::_internal_set_tablespacename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.tablespacename_.Set(value, GetArena());
}
inline std::string* DropTableSpaceStmt::_internal_mutable_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.tablespacename_.Mutable( GetArena());
}
inline std::string* DropTableSpaceStmt::release_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DropTableSpaceStmt.tablespacename)
  return _impl_.tablespacename_.Release();
}
inline void DropTableSpaceStmt::set_allocated_tablespacename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tablespacename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.tablespacename_.IsDefault()) {
          _impl_.tablespacename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.DropTableSpaceStmt.tablespacename)
}

// bool missing_ok = 2 [json_name = "missing_ok"];
inline void DropTableSpaceStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool DropTableSpaceStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.DropTableSpaceStmt.missing_ok)
  return _internal_missing_ok();
}
inline void DropTableSpaceStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.DropTableSpaceStmt.missing_ok)
}
inline bool DropTableSpaceStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void DropTableSpaceStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// -------------------------------------------------------------------

// AlterTableSpaceOptionsStmt

// string tablespacename = 1 [json_name = "tablespacename"];
inline void AlterTableSpaceOptionsStmt::clear_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tablespacename_.ClearToEmpty();
}
inline const std::string& AlterTableSpaceOptionsStmt::tablespacename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableSpaceOptionsStmt.tablespacename)
  return _internal_tablespacename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterTableSpaceOptionsStmt::set_tablespacename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.tablespacename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterTableSpaceOptionsStmt.tablespacename)
}
inline std::string* AlterTableSpaceOptionsStmt::mutable_tablespacename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_tablespacename();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableSpaceOptionsStmt.tablespacename)
  return _s;
}
inline const std::string& AlterTableSpaceOptionsStmt::_internal_tablespacename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.tablespacename_.Get();
}
inline void AlterTableSpaceOptionsStmt::_internal_set_tablespacename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.tablespacename_.Set(value, GetArena());
}
inline std::string* AlterTableSpaceOptionsStmt::_internal_mutable_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.tablespacename_.Mutable( GetArena());
}
inline std::string* AlterTableSpaceOptionsStmt::release_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterTableSpaceOptionsStmt.tablespacename)
  return _impl_.tablespacename_.Release();
}
inline void AlterTableSpaceOptionsStmt::set_allocated_tablespacename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tablespacename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.tablespacename_.IsDefault()) {
          _impl_.tablespacename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int AlterTableSpaceOptionsStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterTableSpaceOptionsStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterTableSpaceOptionsStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableSpaceOptionsStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterTableSpaceOptionsStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTableSpaceOptionsStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterTableSpaceOptionsStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableSpaceOptionsStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterTableSpaceOptionsStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterTableSpaceOptionsStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterTableSpaceOptionsStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterTableSpaceOptionsStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterTableSpaceOptionsStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterTableSpaceOptionsStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// bool is_reset = 3 [json_name = "isReset"];
inline void AlterTableSpaceOptionsStmt::clear_is_reset() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_reset_ = false;
}
inline bool AlterTableSpaceOptionsStmt::is_reset() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableSpaceOptionsStmt.is_reset)
  return _internal_is_reset();
}
inline void AlterTableSpaceOptionsStmt::set_is_reset(bool value) {
  _internal_set_is_reset(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableSpaceOptionsStmt.is_reset)
}
inline bool AlterTableSpaceOptionsStmt::_internal_is_reset() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_reset_;
}
inline void AlterTableSpaceOptionsStmt::_internal_set_is_reset(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_reset_ = value;
}

// -------------------------------------------------------------------

// AlterTableMoveAllStmt

// string orig_tablespacename = 1 [json_name = "orig_tablespacename"];
inline void AlterTableMoveAllStmt::clear_orig_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.orig_tablespacename_.ClearToEmpty();
}
inline const std::string& AlterTableMoveAllStmt::orig_tablespacename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
  return _internal_orig_tablespacename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterTableMoveAllStmt::set_orig_tablespacename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.orig_tablespacename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
}
inline std::string* AlterTableMoveAllStmt::mutable_orig_tablespacename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_orig_tablespacename();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
  return _s;
}
inline const std::string& AlterTableMoveAllStmt::_internal_orig_tablespacename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.orig_tablespacename_.Get();
}
inline void AlterTableMoveAllStmt::_internal_set_orig_tablespacename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.orig_tablespacename_.Set(value, GetArena());
}
inline std::string* AlterTableMoveAllStmt::_internal_mutable_orig_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.orig_tablespacename_.Mutable( GetArena());
}
inline std::string* AlterTableMoveAllStmt::release_orig_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
  return _impl_.orig_tablespacename_.Release();
}
inline void AlterTableMoveAllStmt::set_allocated_orig_tablespacename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.orig_tablespacename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.orig_tablespacename_.IsDefault()) {
          _impl_.orig_tablespacename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableMoveAllStmt.orig_tablespacename)
}

// .pg_query.ObjectType objtype = 2 [json_name = "objtype"];
inline void AlterTableMoveAllStmt::clear_objtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objtype_ = 0;
}
inline ::pg_query::ObjectType AlterTableMoveAllStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.objtype)
  return _internal_objtype();
}
inline void AlterTableMoveAllStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableMoveAllStmt.objtype)
}
inline ::pg_query::ObjectType AlterTableMoveAllStmt::_internal_objtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.objtype_);
}
inline void AlterTableMoveAllStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.objtype_ = value;
}

// repeated .pg_query.Node roles = 3 [json_name = "roles"];
inline int AlterTableMoveAllStmt::_internal_roles_size() const {
  return _internal_roles().size();
}
inline int AlterTableMoveAllStmt::roles_size() const {
  return _internal_roles_size();
}
inline void AlterTableMoveAllStmt::clear_roles() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.roles_.Clear();
}
inline ::pg_query::Node* AlterTableMoveAllStmt::mutable_roles(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableMoveAllStmt.roles)
  return _internal_mutable_roles()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterTableMoveAllStmt::mutable_roles()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTableMoveAllStmt.roles)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_roles();
}
inline const ::pg_query::Node& AlterTableMoveAllStmt::roles(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.roles)
  return _internal_roles().Get(index);
}
inline ::pg_query::Node* AlterTableMoveAllStmt::add_roles() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_roles()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterTableMoveAllStmt.roles)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterTableMoveAllStmt::roles() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterTableMoveAllStmt.roles)
  return _internal_roles();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterTableMoveAllStmt::_internal_roles() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.roles_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterTableMoveAllStmt::_internal_mutable_roles() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.roles_;
}

// string new_tablespacename = 4 [json_name = "new_tablespacename"];
inline void AlterTableMoveAllStmt::clear_new_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.new_tablespacename_.ClearToEmpty();
}
inline const std::string& AlterTableMoveAllStmt::new_tablespacename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.new_tablespacename)
  return _internal_new_tablespacename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterTableMoveAllStmt::set_new_tablespacename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.new_tablespacename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterTableMoveAllStmt.new_tablespacename)
}
inline std::string* AlterTableMoveAllStmt::mutable_new_tablespacename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_new_tablespacename();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTableMoveAllStmt.new_tablespacename)
  return _s;
}
inline const std::string& AlterTableMoveAllStmt::_internal_new_tablespacename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.new_tablespacename_.Get();
}
inline void AlterTableMoveAllStmt::_internal_set_new_tablespacename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.new_tablespacename_.Set(value, GetArena());
}
inline std::string* AlterTableMoveAllStmt::_internal_mutable_new_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.new_tablespacename_.Mutable( GetArena());
}
inline std::string* AlterTableMoveAllStmt::release_new_tablespacename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterTableMoveAllStmt.new_tablespacename)
  return _impl_.new_tablespacename_.Release();
}
inline void AlterTableMoveAllStmt::set_allocated_new_tablespacename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.new_tablespacename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.new_tablespacename_.IsDefault()) {
          _impl_.new_tablespacename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableMoveAllStmt.new_tablespacename)
}

// bool nowait = 5 [json_name = "nowait"];
inline void AlterTableMoveAllStmt::clear_nowait() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.nowait_ = false;
}
inline bool AlterTableMoveAllStmt::nowait() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.nowait)
  return _internal_nowait();
}
inline void AlterTableMoveAllStmt::set_nowait(bool value) {
  _internal_set_nowait(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTableMoveAllStmt.nowait)
}
inline bool AlterTableMoveAllStmt::_internal_nowait() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.nowait_;
}
inline void AlterTableMoveAllStmt::_internal_set_nowait(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.nowait_ = value;
}

// -------------------------------------------------------------------

// CreateExtensionStmt

// string extname = 1 [json_name = "extname"];
inline void CreateExtensionStmt::clear_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.extname_.ClearToEmpty();
}
inline const std::string& CreateExtensionStmt::extname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateExtensionStmt.extname)
  return _internal_extname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateExtensionStmt::set_extname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.extname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateExtensionStmt.extname)
}
inline std::string* CreateExtensionStmt::mutable_extname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_extname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateExtensionStmt.extname)
  return _s;
}
inline const std::string& CreateExtensionStmt::_internal_extname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.extname_.Get();
}
inline void CreateExtensionStmt::_internal_set_extname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.extname_.Set(value, GetArena());
}
inline std::string* CreateExtensionStmt::_internal_mutable_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.extname_.Mutable( GetArena());
}
inline std::string* CreateExtensionStmt::release_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateExtensionStmt.extname)
  return _impl_.extname_.Release();
}
inline void CreateExtensionStmt::set_allocated_extname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.extname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.extname_.IsDefault()) {
          _impl_.extname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.if_not_exists_ = false;
}
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::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateExtensionStmt.if_not_exists)
}
inline bool CreateExtensionStmt::_internal_if_not_exists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.if_not_exists_;
}
inline void CreateExtensionStmt::_internal_set_if_not_exists(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.if_not_exists_ = value;
}

// repeated .pg_query.Node options = 3 [json_name = "options"];
inline int CreateExtensionStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int CreateExtensionStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateExtensionStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreateExtensionStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateExtensionStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateExtensionStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateExtensionStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreateExtensionStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateExtensionStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreateExtensionStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateExtensionStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateExtensionStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateExtensionStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateExtensionStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateExtensionStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// AlterExtensionStmt

// string extname = 1 [json_name = "extname"];
inline void AlterExtensionStmt::clear_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.extname_.ClearToEmpty();
}
inline const std::string& AlterExtensionStmt::extname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterExtensionStmt.extname)
  return _internal_extname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterExtensionStmt::set_extname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.extname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterExtensionStmt.extname)
}
inline std::string* AlterExtensionStmt::mutable_extname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_extname();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterExtensionStmt.extname)
  return _s;
}
inline const std::string& AlterExtensionStmt::_internal_extname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.extname_.Get();
}
inline void AlterExtensionStmt::_internal_set_extname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.extname_.Set(value, GetArena());
}
inline std::string* AlterExtensionStmt::_internal_mutable_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.extname_.Mutable( GetArena());
}
inline std::string* AlterExtensionStmt::release_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterExtensionStmt.extname)
  return _impl_.extname_.Release();
}
inline void AlterExtensionStmt::set_allocated_extname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.extname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.extname_.IsDefault()) {
          _impl_.extname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int AlterExtensionStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterExtensionStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterExtensionStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterExtensionStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterExtensionStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterExtensionStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterExtensionStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterExtensionStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterExtensionStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterExtensionStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterExtensionStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterExtensionStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterExtensionStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterExtensionStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// AlterExtensionContentsStmt

// string extname = 1 [json_name = "extname"];
inline void AlterExtensionContentsStmt::clear_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.extname_.ClearToEmpty();
}
inline const std::string& AlterExtensionContentsStmt::extname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterExtensionContentsStmt.extname)
  return _internal_extname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterExtensionContentsStmt::set_extname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.extname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterExtensionContentsStmt.extname)
}
inline std::string* AlterExtensionContentsStmt::mutable_extname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_extname();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterExtensionContentsStmt.extname)
  return _s;
}
inline const std::string& AlterExtensionContentsStmt::_internal_extname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.extname_.Get();
}
inline void AlterExtensionContentsStmt::_internal_set_extname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.extname_.Set(value, GetArena());
}
inline std::string* AlterExtensionContentsStmt::_internal_mutable_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.extname_.Mutable( GetArena());
}
inline std::string* AlterExtensionContentsStmt::release_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterExtensionContentsStmt.extname)
  return _impl_.extname_.Release();
}
inline void AlterExtensionContentsStmt::set_allocated_extname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.extname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.extname_.IsDefault()) {
          _impl_.extname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterExtensionContentsStmt.extname)
}

// int32 action = 2 [json_name = "action"];
inline void AlterExtensionContentsStmt::clear_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.action_ = 0;
}
inline ::int32_t AlterExtensionContentsStmt::action() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterExtensionContentsStmt.action)
  return _internal_action();
}
inline void AlterExtensionContentsStmt::set_action(::int32_t value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterExtensionContentsStmt.action)
}
inline ::int32_t AlterExtensionContentsStmt::_internal_action() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.action_;
}
inline void AlterExtensionContentsStmt::_internal_set_action(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.action_ = value;
}

// .pg_query.ObjectType objtype = 3 [json_name = "objtype"];
inline void AlterExtensionContentsStmt::clear_objtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objtype_ = 0;
}
inline ::pg_query::ObjectType AlterExtensionContentsStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterExtensionContentsStmt.objtype)
  return _internal_objtype();
}
inline void AlterExtensionContentsStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterExtensionContentsStmt.objtype)
}
inline ::pg_query::ObjectType AlterExtensionContentsStmt::_internal_objtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.objtype_);
}
inline void AlterExtensionContentsStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.objtype_ = value;
}

// .pg_query.Node object = 4 [json_name = "object"];
inline bool AlterExtensionContentsStmt::has_object() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.object_ != nullptr);
  return value;
}
inline void AlterExtensionContentsStmt::clear_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.object_ != nullptr) _impl_.object_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& AlterExtensionContentsStmt::_internal_object() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterExtensionContentsStmt::object() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterExtensionContentsStmt.object)
  return _internal_object();
}
inline void AlterExtensionContentsStmt::unsafe_arena_set_allocated_object(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.object_);
  }
  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterExtensionContentsStmt.object)
}
inline ::pg_query::Node* AlterExtensionContentsStmt::release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.object_;
  _impl_.object_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* AlterExtensionContentsStmt::unsafe_arena_release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterExtensionContentsStmt.object)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.object_;
  _impl_.object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterExtensionContentsStmt::_internal_mutable_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.object_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.object_;
}
inline ::pg_query::Node* AlterExtensionContentsStmt::mutable_object() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_object();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterExtensionContentsStmt.object)
  return _msg;
}
inline void AlterExtensionContentsStmt::set_allocated_object(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.object_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterExtensionContentsStmt.object)
}

// -------------------------------------------------------------------

// CreateFdwStmt

// string fdwname = 1 [json_name = "fdwname"];
inline void CreateFdwStmt::clear_fdwname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fdwname_.ClearToEmpty();
}
inline const std::string& CreateFdwStmt::fdwname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateFdwStmt.fdwname)
  return _internal_fdwname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateFdwStmt::set_fdwname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fdwname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateFdwStmt.fdwname)
}
inline std::string* CreateFdwStmt::mutable_fdwname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_fdwname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFdwStmt.fdwname)
  return _s;
}
inline const std::string& CreateFdwStmt::_internal_fdwname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fdwname_.Get();
}
inline void CreateFdwStmt::_internal_set_fdwname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fdwname_.Set(value, GetArena());
}
inline std::string* CreateFdwStmt::_internal_mutable_fdwname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.fdwname_.Mutable( GetArena());
}
inline std::string* CreateFdwStmt::release_fdwname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateFdwStmt.fdwname)
  return _impl_.fdwname_.Release();
}
inline void CreateFdwStmt::set_allocated_fdwname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fdwname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.fdwname_.IsDefault()) {
          _impl_.fdwname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_func_options().size();
}
inline int CreateFdwStmt::func_options_size() const {
  return _internal_func_options_size();
}
inline void CreateFdwStmt::clear_func_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.func_options_.Clear();
}
inline ::pg_query::Node* CreateFdwStmt::mutable_func_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFdwStmt.func_options)
  return _internal_mutable_func_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateFdwStmt::mutable_func_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFdwStmt.func_options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_func_options();
}
inline const ::pg_query::Node& CreateFdwStmt::func_options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateFdwStmt.func_options)
  return _internal_func_options().Get(index);
}
inline ::pg_query::Node* CreateFdwStmt::add_func_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_func_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateFdwStmt.func_options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateFdwStmt::func_options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateFdwStmt.func_options)
  return _internal_func_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateFdwStmt::_internal_func_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.func_options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateFdwStmt::_internal_mutable_func_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.func_options_;
}

// repeated .pg_query.Node options = 3 [json_name = "options"];
inline int CreateFdwStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int CreateFdwStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateFdwStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreateFdwStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFdwStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateFdwStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFdwStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreateFdwStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateFdwStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreateFdwStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateFdwStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateFdwStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateFdwStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateFdwStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateFdwStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// AlterFdwStmt

// string fdwname = 1 [json_name = "fdwname"];
inline void AlterFdwStmt::clear_fdwname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fdwname_.ClearToEmpty();
}
inline const std::string& AlterFdwStmt::fdwname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterFdwStmt.fdwname)
  return _internal_fdwname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterFdwStmt::set_fdwname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fdwname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterFdwStmt.fdwname)
}
inline std::string* AlterFdwStmt::mutable_fdwname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_fdwname();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterFdwStmt.fdwname)
  return _s;
}
inline const std::string& AlterFdwStmt::_internal_fdwname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fdwname_.Get();
}
inline void AlterFdwStmt::_internal_set_fdwname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fdwname_.Set(value, GetArena());
}
inline std::string* AlterFdwStmt::_internal_mutable_fdwname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.fdwname_.Mutable( GetArena());
}
inline std::string* AlterFdwStmt::release_fdwname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterFdwStmt.fdwname)
  return _impl_.fdwname_.Release();
}
inline void AlterFdwStmt::set_allocated_fdwname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fdwname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.fdwname_.IsDefault()) {
          _impl_.fdwname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_func_options().size();
}
inline int AlterFdwStmt::func_options_size() const {
  return _internal_func_options_size();
}
inline void AlterFdwStmt::clear_func_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.func_options_.Clear();
}
inline ::pg_query::Node* AlterFdwStmt::mutable_func_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterFdwStmt.func_options)
  return _internal_mutable_func_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterFdwStmt::mutable_func_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterFdwStmt.func_options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_func_options();
}
inline const ::pg_query::Node& AlterFdwStmt::func_options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterFdwStmt.func_options)
  return _internal_func_options().Get(index);
}
inline ::pg_query::Node* AlterFdwStmt::add_func_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_func_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterFdwStmt.func_options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterFdwStmt::func_options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterFdwStmt.func_options)
  return _internal_func_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterFdwStmt::_internal_func_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.func_options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterFdwStmt::_internal_mutable_func_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.func_options_;
}

// repeated .pg_query.Node options = 3 [json_name = "options"];
inline int AlterFdwStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int AlterFdwStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterFdwStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterFdwStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterFdwStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterFdwStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterFdwStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterFdwStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterFdwStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterFdwStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterFdwStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterFdwStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterFdwStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterFdwStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterFdwStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// CreateForeignServerStmt

// string servername = 1 [json_name = "servername"];
inline void CreateForeignServerStmt::clear_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servername_.ClearToEmpty();
}
inline const std::string& CreateForeignServerStmt::servername() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.servername)
  return _internal_servername();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateForeignServerStmt::set_servername(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servername_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.servername)
}
inline std::string* CreateForeignServerStmt::mutable_servername() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_servername();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignServerStmt.servername)
  return _s;
}
inline const std::string& CreateForeignServerStmt::_internal_servername() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.servername_.Get();
}
inline void CreateForeignServerStmt::_internal_set_servername(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servername_.Set(value, GetArena());
}
inline std::string* CreateForeignServerStmt::_internal_mutable_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.servername_.Mutable( GetArena());
}
inline std::string* CreateForeignServerStmt::release_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateForeignServerStmt.servername)
  return _impl_.servername_.Release();
}
inline void CreateForeignServerStmt::set_allocated_servername(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servername_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.servername_.IsDefault()) {
          _impl_.servername_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateForeignServerStmt.servername)
}

// string servertype = 2 [json_name = "servertype"];
inline void CreateForeignServerStmt::clear_servertype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servertype_.ClearToEmpty();
}
inline const std::string& CreateForeignServerStmt::servertype() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.servertype)
  return _internal_servertype();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateForeignServerStmt::set_servertype(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servertype_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.servertype)
}
inline std::string* CreateForeignServerStmt::mutable_servertype() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_servertype();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignServerStmt.servertype)
  return _s;
}
inline const std::string& CreateForeignServerStmt::_internal_servertype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.servertype_.Get();
}
inline void CreateForeignServerStmt::_internal_set_servertype(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servertype_.Set(value, GetArena());
}
inline std::string* CreateForeignServerStmt::_internal_mutable_servertype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.servertype_.Mutable( GetArena());
}
inline std::string* CreateForeignServerStmt::release_servertype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateForeignServerStmt.servertype)
  return _impl_.servertype_.Release();
}
inline void CreateForeignServerStmt::set_allocated_servertype(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servertype_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.servertype_.IsDefault()) {
          _impl_.servertype_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateForeignServerStmt.servertype)
}

// string version = 3 [json_name = "version"];
inline void CreateForeignServerStmt::clear_version() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.version_.ClearToEmpty();
}
inline const std::string& CreateForeignServerStmt::version() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.version)
  return _internal_version();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateForeignServerStmt::set_version(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.version_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.version)
}
inline std::string* CreateForeignServerStmt::mutable_version() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignServerStmt.version)
  return _s;
}
inline const std::string& CreateForeignServerStmt::_internal_version() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.version_.Get();
}
inline void CreateForeignServerStmt::_internal_set_version(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.version_.Set(value, GetArena());
}
inline std::string* CreateForeignServerStmt::_internal_mutable_version() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.version_.Mutable( GetArena());
}
inline std::string* CreateForeignServerStmt::release_version() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateForeignServerStmt.version)
  return _impl_.version_.Release();
}
inline void CreateForeignServerStmt::set_allocated_version(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.version_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.version_.IsDefault()) {
          _impl_.version_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateForeignServerStmt.version)
}

// string fdwname = 4 [json_name = "fdwname"];
inline void CreateForeignServerStmt::clear_fdwname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fdwname_.ClearToEmpty();
}
inline const std::string& CreateForeignServerStmt::fdwname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.fdwname)
  return _internal_fdwname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateForeignServerStmt::set_fdwname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fdwname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.fdwname)
}
inline std::string* CreateForeignServerStmt::mutable_fdwname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_fdwname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignServerStmt.fdwname)
  return _s;
}
inline const std::string& CreateForeignServerStmt::_internal_fdwname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.fdwname_.Get();
}
inline void CreateForeignServerStmt::_internal_set_fdwname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.fdwname_.Set(value, GetArena());
}
inline std::string* CreateForeignServerStmt::_internal_mutable_fdwname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.fdwname_.Mutable( GetArena());
}
inline std::string* CreateForeignServerStmt::release_fdwname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateForeignServerStmt.fdwname)
  return _impl_.fdwname_.Release();
}
inline void CreateForeignServerStmt::set_allocated_fdwname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.fdwname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.fdwname_.IsDefault()) {
          _impl_.fdwname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.if_not_exists_ = false;
}
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::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.if_not_exists)
}
inline bool CreateForeignServerStmt::_internal_if_not_exists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.if_not_exists_;
}
inline void CreateForeignServerStmt::_internal_set_if_not_exists(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.if_not_exists_ = value;
}

// repeated .pg_query.Node options = 6 [json_name = "options"];
inline int CreateForeignServerStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int CreateForeignServerStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateForeignServerStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreateForeignServerStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignServerStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateForeignServerStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateForeignServerStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreateForeignServerStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreateForeignServerStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateForeignServerStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateForeignServerStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateForeignServerStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateForeignServerStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateForeignServerStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// AlterForeignServerStmt

// string servername = 1 [json_name = "servername"];
inline void AlterForeignServerStmt::clear_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servername_.ClearToEmpty();
}
inline const std::string& AlterForeignServerStmt::servername() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterForeignServerStmt.servername)
  return _internal_servername();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterForeignServerStmt::set_servername(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servername_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterForeignServerStmt.servername)
}
inline std::string* AlterForeignServerStmt::mutable_servername() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_servername();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterForeignServerStmt.servername)
  return _s;
}
inline const std::string& AlterForeignServerStmt::_internal_servername() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.servername_.Get();
}
inline void AlterForeignServerStmt::_internal_set_servername(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servername_.Set(value, GetArena());
}
inline std::string* AlterForeignServerStmt::_internal_mutable_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.servername_.Mutable( GetArena());
}
inline std::string* AlterForeignServerStmt::release_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterForeignServerStmt.servername)
  return _impl_.servername_.Release();
}
inline void AlterForeignServerStmt::set_allocated_servername(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servername_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.servername_.IsDefault()) {
          _impl_.servername_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterForeignServerStmt.servername)
}

// string version = 2 [json_name = "version"];
inline void AlterForeignServerStmt::clear_version() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.version_.ClearToEmpty();
}
inline const std::string& AlterForeignServerStmt::version() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterForeignServerStmt.version)
  return _internal_version();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterForeignServerStmt::set_version(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.version_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterForeignServerStmt.version)
}
inline std::string* AlterForeignServerStmt::mutable_version() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterForeignServerStmt.version)
  return _s;
}
inline const std::string& AlterForeignServerStmt::_internal_version() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.version_.Get();
}
inline void AlterForeignServerStmt::_internal_set_version(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.version_.Set(value, GetArena());
}
inline std::string* AlterForeignServerStmt::_internal_mutable_version() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.version_.Mutable( GetArena());
}
inline std::string* AlterForeignServerStmt::release_version() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterForeignServerStmt.version)
  return _impl_.version_.Release();
}
inline void AlterForeignServerStmt::set_allocated_version(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.version_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.version_.IsDefault()) {
          _impl_.version_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int AlterForeignServerStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterForeignServerStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterForeignServerStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterForeignServerStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterForeignServerStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterForeignServerStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterForeignServerStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterForeignServerStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterForeignServerStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterForeignServerStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterForeignServerStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterForeignServerStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterForeignServerStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterForeignServerStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// bool has_version = 4 [json_name = "has_version"];
inline void AlterForeignServerStmt::clear_has_version() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.has_version_ = false;
}
inline bool AlterForeignServerStmt::has_version() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterForeignServerStmt.has_version)
  return _internal_has_version();
}
inline void AlterForeignServerStmt::set_has_version(bool value) {
  _internal_set_has_version(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterForeignServerStmt.has_version)
}
inline bool AlterForeignServerStmt::_internal_has_version() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.has_version_;
}
inline void AlterForeignServerStmt::_internal_set_has_version(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.has_version_ = value;
}

// -------------------------------------------------------------------

// CreateForeignTableStmt

// .pg_query.CreateStmt base_stmt = 1 [json_name = "base"];
inline bool CreateForeignTableStmt::has_base_stmt() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.base_stmt_ != nullptr);
  return value;
}
inline void CreateForeignTableStmt::clear_base_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.base_stmt_ != nullptr) _impl_.base_stmt_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::CreateStmt& CreateForeignTableStmt::_internal_base_stmt() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::CreateStmt* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.base_stmt_);
  }
  _impl_.base_stmt_ = reinterpret_cast<::pg_query::CreateStmt*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateForeignTableStmt.base_stmt)
}
inline ::pg_query::CreateStmt* CreateForeignTableStmt::release_base_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::CreateStmt* released = _impl_.base_stmt_;
  _impl_.base_stmt_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::CreateStmt* CreateForeignTableStmt::unsafe_arena_release_base_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateForeignTableStmt.base_stmt)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::CreateStmt* temp = _impl_.base_stmt_;
  _impl_.base_stmt_ = nullptr;
  return temp;
}
inline ::pg_query::CreateStmt* CreateForeignTableStmt::_internal_mutable_base_stmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.base_stmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::CreateStmt>(GetArena());
    _impl_.base_stmt_ = reinterpret_cast<::pg_query::CreateStmt*>(p);
  }
  return _impl_.base_stmt_;
}
inline ::pg_query::CreateStmt* CreateForeignTableStmt::mutable_base_stmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CreateStmt* _msg = _internal_mutable_base_stmt();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignTableStmt.base_stmt)
  return _msg;
}
inline void CreateForeignTableStmt::set_allocated_base_stmt(::pg_query::CreateStmt* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::CreateStmt*>(_impl_.base_stmt_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::CreateStmt*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.base_stmt_ = reinterpret_cast<::pg_query::CreateStmt*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateForeignTableStmt.base_stmt)
}

// string servername = 2 [json_name = "servername"];
inline void CreateForeignTableStmt::clear_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servername_.ClearToEmpty();
}
inline const std::string& CreateForeignTableStmt::servername() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignTableStmt.servername)
  return _internal_servername();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateForeignTableStmt::set_servername(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servername_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateForeignTableStmt.servername)
}
inline std::string* CreateForeignTableStmt::mutable_servername() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_servername();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignTableStmt.servername)
  return _s;
}
inline const std::string& CreateForeignTableStmt::_internal_servername() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.servername_.Get();
}
inline void CreateForeignTableStmt::_internal_set_servername(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servername_.Set(value, GetArena());
}
inline std::string* CreateForeignTableStmt::_internal_mutable_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.servername_.Mutable( GetArena());
}
inline std::string* CreateForeignTableStmt::release_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateForeignTableStmt.servername)
  return _impl_.servername_.Release();
}
inline void CreateForeignTableStmt::set_allocated_servername(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servername_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.servername_.IsDefault()) {
          _impl_.servername_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int CreateForeignTableStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateForeignTableStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreateForeignTableStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignTableStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateForeignTableStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateForeignTableStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreateForeignTableStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateForeignTableStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreateForeignTableStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateForeignTableStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateForeignTableStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateForeignTableStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateForeignTableStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateForeignTableStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// CreateUserMappingStmt

// .pg_query.RoleSpec user = 1 [json_name = "user"];
inline bool CreateUserMappingStmt::has_user() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.user_ != nullptr);
  return value;
}
inline void CreateUserMappingStmt::clear_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.user_ != nullptr) _impl_.user_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RoleSpec& CreateUserMappingStmt::_internal_user() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RoleSpec* p = _impl_.user_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& CreateUserMappingStmt::user() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateUserMappingStmt.user)
  return _internal_user();
}
inline void CreateUserMappingStmt::unsafe_arena_set_allocated_user(::pg_query::RoleSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.user_);
  }
  _impl_.user_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateUserMappingStmt.user)
}
inline ::pg_query::RoleSpec* CreateUserMappingStmt::release_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* released = _impl_.user_;
  _impl_.user_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RoleSpec* CreateUserMappingStmt::unsafe_arena_release_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateUserMappingStmt.user)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* temp = _impl_.user_;
  _impl_.user_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* CreateUserMappingStmt::_internal_mutable_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.user_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    _impl_.user_ = reinterpret_cast<::pg_query::RoleSpec*>(p);
  }
  return _impl_.user_;
}
inline ::pg_query::RoleSpec* CreateUserMappingStmt::mutable_user() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_user();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateUserMappingStmt.user)
  return _msg;
}
inline void CreateUserMappingStmt::set_allocated_user(::pg_query::RoleSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RoleSpec*>(_impl_.user_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RoleSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.user_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateUserMappingStmt.user)
}

// string servername = 2 [json_name = "servername"];
inline void CreateUserMappingStmt::clear_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servername_.ClearToEmpty();
}
inline const std::string& CreateUserMappingStmt::servername() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateUserMappingStmt.servername)
  return _internal_servername();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateUserMappingStmt::set_servername(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servername_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateUserMappingStmt.servername)
}
inline std::string* CreateUserMappingStmt::mutable_servername() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_servername();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateUserMappingStmt.servername)
  return _s;
}
inline const std::string& CreateUserMappingStmt::_internal_servername() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.servername_.Get();
}
inline void CreateUserMappingStmt::_internal_set_servername(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servername_.Set(value, GetArena());
}
inline std::string* CreateUserMappingStmt::_internal_mutable_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.servername_.Mutable( GetArena());
}
inline std::string* CreateUserMappingStmt::release_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateUserMappingStmt.servername)
  return _impl_.servername_.Release();
}
inline void CreateUserMappingStmt::set_allocated_servername(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servername_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.servername_.IsDefault()) {
          _impl_.servername_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.if_not_exists_ = false;
}
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::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateUserMappingStmt.if_not_exists)
}
inline bool CreateUserMappingStmt::_internal_if_not_exists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.if_not_exists_;
}
inline void CreateUserMappingStmt::_internal_set_if_not_exists(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.if_not_exists_ = value;
}

// repeated .pg_query.Node options = 4 [json_name = "options"];
inline int CreateUserMappingStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int CreateUserMappingStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateUserMappingStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreateUserMappingStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateUserMappingStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateUserMappingStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateUserMappingStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreateUserMappingStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateUserMappingStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreateUserMappingStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateUserMappingStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateUserMappingStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateUserMappingStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateUserMappingStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateUserMappingStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// AlterUserMappingStmt

// .pg_query.RoleSpec user = 1 [json_name = "user"];
inline bool AlterUserMappingStmt::has_user() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.user_ != nullptr);
  return value;
}
inline void AlterUserMappingStmt::clear_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.user_ != nullptr) _impl_.user_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RoleSpec& AlterUserMappingStmt::_internal_user() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RoleSpec* p = _impl_.user_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& AlterUserMappingStmt::user() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterUserMappingStmt.user)
  return _internal_user();
}
inline void AlterUserMappingStmt::unsafe_arena_set_allocated_user(::pg_query::RoleSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.user_);
  }
  _impl_.user_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterUserMappingStmt.user)
}
inline ::pg_query::RoleSpec* AlterUserMappingStmt::release_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* released = _impl_.user_;
  _impl_.user_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RoleSpec* AlterUserMappingStmt::unsafe_arena_release_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterUserMappingStmt.user)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* temp = _impl_.user_;
  _impl_.user_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* AlterUserMappingStmt::_internal_mutable_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.user_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    _impl_.user_ = reinterpret_cast<::pg_query::RoleSpec*>(p);
  }
  return _impl_.user_;
}
inline ::pg_query::RoleSpec* AlterUserMappingStmt::mutable_user() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_user();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterUserMappingStmt.user)
  return _msg;
}
inline void AlterUserMappingStmt::set_allocated_user(::pg_query::RoleSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RoleSpec*>(_impl_.user_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RoleSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.user_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterUserMappingStmt.user)
}

// string servername = 2 [json_name = "servername"];
inline void AlterUserMappingStmt::clear_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servername_.ClearToEmpty();
}
inline const std::string& AlterUserMappingStmt::servername() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterUserMappingStmt.servername)
  return _internal_servername();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterUserMappingStmt::set_servername(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servername_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterUserMappingStmt.servername)
}
inline std::string* AlterUserMappingStmt::mutable_servername() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_servername();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterUserMappingStmt.servername)
  return _s;
}
inline const std::string& AlterUserMappingStmt::_internal_servername() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.servername_.Get();
}
inline void AlterUserMappingStmt::_internal_set_servername(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servername_.Set(value, GetArena());
}
inline std::string* AlterUserMappingStmt::_internal_mutable_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.servername_.Mutable( GetArena());
}
inline std::string* AlterUserMappingStmt::release_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterUserMappingStmt.servername)
  return _impl_.servername_.Release();
}
inline void AlterUserMappingStmt::set_allocated_servername(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servername_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.servername_.IsDefault()) {
          _impl_.servername_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int AlterUserMappingStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterUserMappingStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterUserMappingStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterUserMappingStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterUserMappingStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterUserMappingStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterUserMappingStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterUserMappingStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterUserMappingStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterUserMappingStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterUserMappingStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterUserMappingStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterUserMappingStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterUserMappingStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// DropUserMappingStmt

// .pg_query.RoleSpec user = 1 [json_name = "user"];
inline bool DropUserMappingStmt::has_user() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.user_ != nullptr);
  return value;
}
inline void DropUserMappingStmt::clear_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.user_ != nullptr) _impl_.user_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RoleSpec& DropUserMappingStmt::_internal_user() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RoleSpec* p = _impl_.user_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& DropUserMappingStmt::user() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DropUserMappingStmt.user)
  return _internal_user();
}
inline void DropUserMappingStmt::unsafe_arena_set_allocated_user(::pg_query::RoleSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.user_);
  }
  _impl_.user_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DropUserMappingStmt.user)
}
inline ::pg_query::RoleSpec* DropUserMappingStmt::release_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* released = _impl_.user_;
  _impl_.user_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RoleSpec* DropUserMappingStmt::unsafe_arena_release_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DropUserMappingStmt.user)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* temp = _impl_.user_;
  _impl_.user_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* DropUserMappingStmt::_internal_mutable_user() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.user_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    _impl_.user_ = reinterpret_cast<::pg_query::RoleSpec*>(p);
  }
  return _impl_.user_;
}
inline ::pg_query::RoleSpec* DropUserMappingStmt::mutable_user() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_user();
  // @@protoc_insertion_point(field_mutable:pg_query.DropUserMappingStmt.user)
  return _msg;
}
inline void DropUserMappingStmt::set_allocated_user(::pg_query::RoleSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RoleSpec*>(_impl_.user_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RoleSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.user_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.DropUserMappingStmt.user)
}

// string servername = 2 [json_name = "servername"];
inline void DropUserMappingStmt::clear_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servername_.ClearToEmpty();
}
inline const std::string& DropUserMappingStmt::servername() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DropUserMappingStmt.servername)
  return _internal_servername();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DropUserMappingStmt::set_servername(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servername_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.DropUserMappingStmt.servername)
}
inline std::string* DropUserMappingStmt::mutable_servername() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_servername();
  // @@protoc_insertion_point(field_mutable:pg_query.DropUserMappingStmt.servername)
  return _s;
}
inline const std::string& DropUserMappingStmt::_internal_servername() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.servername_.Get();
}
inline void DropUserMappingStmt::_internal_set_servername(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.servername_.Set(value, GetArena());
}
inline std::string* DropUserMappingStmt::_internal_mutable_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.servername_.Mutable( GetArena());
}
inline std::string* DropUserMappingStmt::release_servername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DropUserMappingStmt.servername)
  return _impl_.servername_.Release();
}
inline void DropUserMappingStmt::set_allocated_servername(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.servername_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.servername_.IsDefault()) {
          _impl_.servername_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.DropUserMappingStmt.servername)
}

// bool missing_ok = 3 [json_name = "missing_ok"];
inline void DropUserMappingStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool DropUserMappingStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.DropUserMappingStmt.missing_ok)
  return _internal_missing_ok();
}
inline void DropUserMappingStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.DropUserMappingStmt.missing_ok)
}
inline bool DropUserMappingStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void DropUserMappingStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// -------------------------------------------------------------------

// ImportForeignSchemaStmt

// string server_name = 1 [json_name = "server_name"];
inline void ImportForeignSchemaStmt::clear_server_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.server_name_.ClearToEmpty();
}
inline const std::string& ImportForeignSchemaStmt::server_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.server_name)
  return _internal_server_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ImportForeignSchemaStmt::set_server_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.server_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ImportForeignSchemaStmt.server_name)
}
inline std::string* ImportForeignSchemaStmt::mutable_server_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_server_name();
  // @@protoc_insertion_point(field_mutable:pg_query.ImportForeignSchemaStmt.server_name)
  return _s;
}
inline const std::string& ImportForeignSchemaStmt::_internal_server_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.server_name_.Get();
}
inline void ImportForeignSchemaStmt::_internal_set_server_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.server_name_.Set(value, GetArena());
}
inline std::string* ImportForeignSchemaStmt::_internal_mutable_server_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.server_name_.Mutable( GetArena());
}
inline std::string* ImportForeignSchemaStmt::release_server_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ImportForeignSchemaStmt.server_name)
  return _impl_.server_name_.Release();
}
inline void ImportForeignSchemaStmt::set_allocated_server_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.server_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.server_name_.IsDefault()) {
          _impl_.server_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.remote_schema_.ClearToEmpty();
}
inline const std::string& ImportForeignSchemaStmt::remote_schema() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.remote_schema)
  return _internal_remote_schema();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ImportForeignSchemaStmt::set_remote_schema(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.remote_schema_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ImportForeignSchemaStmt.remote_schema)
}
inline std::string* ImportForeignSchemaStmt::mutable_remote_schema() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_remote_schema();
  // @@protoc_insertion_point(field_mutable:pg_query.ImportForeignSchemaStmt.remote_schema)
  return _s;
}
inline const std::string& ImportForeignSchemaStmt::_internal_remote_schema() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.remote_schema_.Get();
}
inline void ImportForeignSchemaStmt::_internal_set_remote_schema(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.remote_schema_.Set(value, GetArena());
}
inline std::string* ImportForeignSchemaStmt::_internal_mutable_remote_schema() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.remote_schema_.Mutable( GetArena());
}
inline std::string* ImportForeignSchemaStmt::release_remote_schema() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ImportForeignSchemaStmt.remote_schema)
  return _impl_.remote_schema_.Release();
}
inline void ImportForeignSchemaStmt::set_allocated_remote_schema(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.remote_schema_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.remote_schema_.IsDefault()) {
          _impl_.remote_schema_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.local_schema_.ClearToEmpty();
}
inline const std::string& ImportForeignSchemaStmt::local_schema() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.local_schema)
  return _internal_local_schema();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ImportForeignSchemaStmt::set_local_schema(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.local_schema_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ImportForeignSchemaStmt.local_schema)
}
inline std::string* ImportForeignSchemaStmt::mutable_local_schema() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_local_schema();
  // @@protoc_insertion_point(field_mutable:pg_query.ImportForeignSchemaStmt.local_schema)
  return _s;
}
inline const std::string& ImportForeignSchemaStmt::_internal_local_schema() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.local_schema_.Get();
}
inline void ImportForeignSchemaStmt::_internal_set_local_schema(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.local_schema_.Set(value, GetArena());
}
inline std::string* ImportForeignSchemaStmt::_internal_mutable_local_schema() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.local_schema_.Mutable( GetArena());
}
inline std::string* ImportForeignSchemaStmt::release_local_schema() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ImportForeignSchemaStmt.local_schema)
  return _impl_.local_schema_.Release();
}
inline void ImportForeignSchemaStmt::set_allocated_local_schema(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.local_schema_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.local_schema_.IsDefault()) {
          _impl_.local_schema_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.list_type_ = 0;
}
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::set_list_type(::pg_query::ImportForeignSchemaType value) {
  _internal_set_list_type(value);
  // @@protoc_insertion_point(field_set:pg_query.ImportForeignSchemaStmt.list_type)
}
inline ::pg_query::ImportForeignSchemaType ImportForeignSchemaStmt::_internal_list_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ImportForeignSchemaType>(_impl_.list_type_);
}
inline void ImportForeignSchemaStmt::_internal_set_list_type(::pg_query::ImportForeignSchemaType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.list_type_ = value;
}

// repeated .pg_query.Node table_list = 5 [json_name = "table_list"];
inline int ImportForeignSchemaStmt::_internal_table_list_size() const {
  return _internal_table_list().size();
}
inline int ImportForeignSchemaStmt::table_list_size() const {
  return _internal_table_list_size();
}
inline void ImportForeignSchemaStmt::clear_table_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.table_list_.Clear();
}
inline ::pg_query::Node* ImportForeignSchemaStmt::mutable_table_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ImportForeignSchemaStmt.table_list)
  return _internal_mutable_table_list()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ImportForeignSchemaStmt::mutable_table_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ImportForeignSchemaStmt.table_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_table_list();
}
inline const ::pg_query::Node& ImportForeignSchemaStmt::table_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.table_list)
  return _internal_table_list().Get(index);
}
inline ::pg_query::Node* ImportForeignSchemaStmt::add_table_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_table_list()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ImportForeignSchemaStmt.table_list)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ImportForeignSchemaStmt::table_list() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ImportForeignSchemaStmt.table_list)
  return _internal_table_list();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ImportForeignSchemaStmt::_internal_table_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.table_list_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ImportForeignSchemaStmt::_internal_mutable_table_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.table_list_;
}

// repeated .pg_query.Node options = 6 [json_name = "options"];
inline int ImportForeignSchemaStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int ImportForeignSchemaStmt::options_size() const {
  return _internal_options_size();
}
inline void ImportForeignSchemaStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* ImportForeignSchemaStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ImportForeignSchemaStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ImportForeignSchemaStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ImportForeignSchemaStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& ImportForeignSchemaStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* ImportForeignSchemaStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ImportForeignSchemaStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ImportForeignSchemaStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ImportForeignSchemaStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ImportForeignSchemaStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ImportForeignSchemaStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// CreatePolicyStmt

// string policy_name = 1 [json_name = "policy_name"];
inline void CreatePolicyStmt::clear_policy_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.policy_name_.ClearToEmpty();
}
inline const std::string& CreatePolicyStmt::policy_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.policy_name)
  return _internal_policy_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreatePolicyStmt::set_policy_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.policy_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreatePolicyStmt.policy_name)
}
inline std::string* CreatePolicyStmt::mutable_policy_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_policy_name();
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.policy_name)
  return _s;
}
inline const std::string& CreatePolicyStmt::_internal_policy_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.policy_name_.Get();
}
inline void CreatePolicyStmt::_internal_set_policy_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.policy_name_.Set(value, GetArena());
}
inline std::string* CreatePolicyStmt::_internal_mutable_policy_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.policy_name_.Mutable( GetArena());
}
inline std::string* CreatePolicyStmt::release_policy_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.policy_name)
  return _impl_.policy_name_.Release();
}
inline void CreatePolicyStmt::set_allocated_policy_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.policy_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.policy_name_.IsDefault()) {
          _impl_.policy_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePolicyStmt.policy_name)
}

// .pg_query.RangeVar table = 2 [json_name = "table"];
inline bool CreatePolicyStmt::has_table() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.table_ != nullptr);
  return value;
}
inline void CreatePolicyStmt::clear_table() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.table_ != nullptr) _impl_.table_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& CreatePolicyStmt::_internal_table() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.table_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CreatePolicyStmt::table() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.table)
  return _internal_table();
}
inline void CreatePolicyStmt::unsafe_arena_set_allocated_table(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.table_);
  }
  _impl_.table_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreatePolicyStmt.table)
}
inline ::pg_query::RangeVar* CreatePolicyStmt::release_table() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.table_;
  _impl_.table_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* CreatePolicyStmt::unsafe_arena_release_table() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.table)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.table_;
  _impl_.table_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CreatePolicyStmt::_internal_mutable_table() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.table_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.table_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.table_;
}
inline ::pg_query::RangeVar* CreatePolicyStmt::mutable_table() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_table();
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.table)
  return _msg;
}
inline void CreatePolicyStmt::set_allocated_table(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.table_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.table_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePolicyStmt.table)
}

// string cmd_name = 3 [json_name = "cmd_name"];
inline void CreatePolicyStmt::clear_cmd_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cmd_name_.ClearToEmpty();
}
inline const std::string& CreatePolicyStmt::cmd_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.cmd_name)
  return _internal_cmd_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreatePolicyStmt::set_cmd_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cmd_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreatePolicyStmt.cmd_name)
}
inline std::string* CreatePolicyStmt::mutable_cmd_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_cmd_name();
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.cmd_name)
  return _s;
}
inline const std::string& CreatePolicyStmt::_internal_cmd_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cmd_name_.Get();
}
inline void CreatePolicyStmt::_internal_set_cmd_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.cmd_name_.Set(value, GetArena());
}
inline std::string* CreatePolicyStmt::_internal_mutable_cmd_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.cmd_name_.Mutable( GetArena());
}
inline std::string* CreatePolicyStmt::release_cmd_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.cmd_name)
  return _impl_.cmd_name_.Release();
}
inline void CreatePolicyStmt::set_allocated_cmd_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cmd_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.cmd_name_.IsDefault()) {
          _impl_.cmd_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePolicyStmt.cmd_name)
}

// bool permissive = 4 [json_name = "permissive"];
inline void CreatePolicyStmt::clear_permissive() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.permissive_ = false;
}
inline bool CreatePolicyStmt::permissive() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.permissive)
  return _internal_permissive();
}
inline void CreatePolicyStmt::set_permissive(bool value) {
  _internal_set_permissive(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatePolicyStmt.permissive)
}
inline bool CreatePolicyStmt::_internal_permissive() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.permissive_;
}
inline void CreatePolicyStmt::_internal_set_permissive(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.permissive_ = value;
}

// repeated .pg_query.Node roles = 5 [json_name = "roles"];
inline int CreatePolicyStmt::_internal_roles_size() const {
  return _internal_roles().size();
}
inline int CreatePolicyStmt::roles_size() const {
  return _internal_roles_size();
}
inline void CreatePolicyStmt::clear_roles() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.roles_.Clear();
}
inline ::pg_query::Node* CreatePolicyStmt::mutable_roles(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.roles)
  return _internal_mutable_roles()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreatePolicyStmt::mutable_roles()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePolicyStmt.roles)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_roles();
}
inline const ::pg_query::Node& CreatePolicyStmt::roles(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.roles)
  return _internal_roles().Get(index);
}
inline ::pg_query::Node* CreatePolicyStmt::add_roles() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_roles()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreatePolicyStmt.roles)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreatePolicyStmt::roles() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreatePolicyStmt.roles)
  return _internal_roles();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreatePolicyStmt::_internal_roles() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.roles_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreatePolicyStmt::_internal_mutable_roles() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.roles_;
}

// .pg_query.Node qual = 6 [json_name = "qual"];
inline bool CreatePolicyStmt::has_qual() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.qual_ != nullptr);
  return value;
}
inline void CreatePolicyStmt::clear_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.qual_ != nullptr) _impl_.qual_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& CreatePolicyStmt::_internal_qual() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.qual_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CreatePolicyStmt::qual() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.qual)
  return _internal_qual();
}
inline void CreatePolicyStmt::unsafe_arena_set_allocated_qual(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.qual_);
  }
  _impl_.qual_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreatePolicyStmt.qual)
}
inline ::pg_query::Node* CreatePolicyStmt::release_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.qual_;
  _impl_.qual_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CreatePolicyStmt::unsafe_arena_release_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.qual)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.qual_;
  _impl_.qual_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CreatePolicyStmt::_internal_mutable_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.qual_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.qual_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.qual_;
}
inline ::pg_query::Node* CreatePolicyStmt::mutable_qual() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_qual();
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.qual)
  return _msg;
}
inline void CreatePolicyStmt::set_allocated_qual(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.qual_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.qual_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePolicyStmt.qual)
}

// .pg_query.Node with_check = 7 [json_name = "with_check"];
inline bool CreatePolicyStmt::has_with_check() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.with_check_ != nullptr);
  return value;
}
inline void CreatePolicyStmt::clear_with_check() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.with_check_ != nullptr) _impl_.with_check_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& CreatePolicyStmt::_internal_with_check() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.with_check_);
  }
  _impl_.with_check_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreatePolicyStmt.with_check)
}
inline ::pg_query::Node* CreatePolicyStmt::release_with_check() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.with_check_;
  _impl_.with_check_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CreatePolicyStmt::unsafe_arena_release_with_check() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.with_check)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.with_check_;
  _impl_.with_check_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CreatePolicyStmt::_internal_mutable_with_check() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.with_check_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.with_check_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.with_check_;
}
inline ::pg_query::Node* CreatePolicyStmt::mutable_with_check() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_with_check();
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.with_check)
  return _msg;
}
inline void CreatePolicyStmt::set_allocated_with_check(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.with_check_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.with_check_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.policy_name_.ClearToEmpty();
}
inline const std::string& AlterPolicyStmt::policy_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.policy_name)
  return _internal_policy_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterPolicyStmt::set_policy_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.policy_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterPolicyStmt.policy_name)
}
inline std::string* AlterPolicyStmt::mutable_policy_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_policy_name();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPolicyStmt.policy_name)
  return _s;
}
inline const std::string& AlterPolicyStmt::_internal_policy_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.policy_name_.Get();
}
inline void AlterPolicyStmt::_internal_set_policy_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.policy_name_.Set(value, GetArena());
}
inline std::string* AlterPolicyStmt::_internal_mutable_policy_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.policy_name_.Mutable( GetArena());
}
inline std::string* AlterPolicyStmt::release_policy_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterPolicyStmt.policy_name)
  return _impl_.policy_name_.Release();
}
inline void AlterPolicyStmt::set_allocated_policy_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.policy_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.policy_name_.IsDefault()) {
          _impl_.policy_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterPolicyStmt.policy_name)
}

// .pg_query.RangeVar table = 2 [json_name = "table"];
inline bool AlterPolicyStmt::has_table() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.table_ != nullptr);
  return value;
}
inline void AlterPolicyStmt::clear_table() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.table_ != nullptr) _impl_.table_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& AlterPolicyStmt::_internal_table() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.table_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& AlterPolicyStmt::table() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.table)
  return _internal_table();
}
inline void AlterPolicyStmt::unsafe_arena_set_allocated_table(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.table_);
  }
  _impl_.table_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterPolicyStmt.table)
}
inline ::pg_query::RangeVar* AlterPolicyStmt::release_table() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.table_;
  _impl_.table_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* AlterPolicyStmt::unsafe_arena_release_table() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterPolicyStmt.table)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.table_;
  _impl_.table_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* AlterPolicyStmt::_internal_mutable_table() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.table_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.table_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.table_;
}
inline ::pg_query::RangeVar* AlterPolicyStmt::mutable_table() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_table();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPolicyStmt.table)
  return _msg;
}
inline void AlterPolicyStmt::set_allocated_table(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.table_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.table_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@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 _internal_roles().size();
}
inline int AlterPolicyStmt::roles_size() const {
  return _internal_roles_size();
}
inline void AlterPolicyStmt::clear_roles() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.roles_.Clear();
}
inline ::pg_query::Node* AlterPolicyStmt::mutable_roles(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPolicyStmt.roles)
  return _internal_mutable_roles()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterPolicyStmt::mutable_roles()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterPolicyStmt.roles)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_roles();
}
inline const ::pg_query::Node& AlterPolicyStmt::roles(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.roles)
  return _internal_roles().Get(index);
}
inline ::pg_query::Node* AlterPolicyStmt::add_roles() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_roles()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterPolicyStmt.roles)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterPolicyStmt::roles() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterPolicyStmt.roles)
  return _internal_roles();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterPolicyStmt::_internal_roles() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.roles_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterPolicyStmt::_internal_mutable_roles() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.roles_;
}

// .pg_query.Node qual = 4 [json_name = "qual"];
inline bool AlterPolicyStmt::has_qual() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.qual_ != nullptr);
  return value;
}
inline void AlterPolicyStmt::clear_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.qual_ != nullptr) _impl_.qual_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& AlterPolicyStmt::_internal_qual() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.qual_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterPolicyStmt::qual() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.qual)
  return _internal_qual();
}
inline void AlterPolicyStmt::unsafe_arena_set_allocated_qual(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.qual_);
  }
  _impl_.qual_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterPolicyStmt.qual)
}
inline ::pg_query::Node* AlterPolicyStmt::release_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.qual_;
  _impl_.qual_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* AlterPolicyStmt::unsafe_arena_release_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterPolicyStmt.qual)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.qual_;
  _impl_.qual_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterPolicyStmt::_internal_mutable_qual() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.qual_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.qual_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.qual_;
}
inline ::pg_query::Node* AlterPolicyStmt::mutable_qual() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_qual();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPolicyStmt.qual)
  return _msg;
}
inline void AlterPolicyStmt::set_allocated_qual(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.qual_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.qual_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterPolicyStmt.qual)
}

// .pg_query.Node with_check = 5 [json_name = "with_check"];
inline bool AlterPolicyStmt::has_with_check() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.with_check_ != nullptr);
  return value;
}
inline void AlterPolicyStmt::clear_with_check() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.with_check_ != nullptr) _impl_.with_check_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::Node& AlterPolicyStmt::_internal_with_check() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.with_check_);
  }
  _impl_.with_check_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterPolicyStmt.with_check)
}
inline ::pg_query::Node* AlterPolicyStmt::release_with_check() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* released = _impl_.with_check_;
  _impl_.with_check_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* AlterPolicyStmt::unsafe_arena_release_with_check() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterPolicyStmt.with_check)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::Node* temp = _impl_.with_check_;
  _impl_.with_check_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterPolicyStmt::_internal_mutable_with_check() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.with_check_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.with_check_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.with_check_;
}
inline ::pg_query::Node* AlterPolicyStmt::mutable_with_check() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_with_check();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPolicyStmt.with_check)
  return _msg;
}
inline void AlterPolicyStmt::set_allocated_with_check(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.with_check_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.with_check_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterPolicyStmt.with_check)
}

// -------------------------------------------------------------------

// CreateAmStmt

// string amname = 1 [json_name = "amname"];
inline void CreateAmStmt::clear_amname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.amname_.ClearToEmpty();
}
inline const std::string& CreateAmStmt::amname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateAmStmt.amname)
  return _internal_amname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateAmStmt::set_amname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.amname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateAmStmt.amname)
}
inline std::string* CreateAmStmt::mutable_amname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_amname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateAmStmt.amname)
  return _s;
}
inline const std::string& CreateAmStmt::_internal_amname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.amname_.Get();
}
inline void CreateAmStmt::_internal_set_amname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.amname_.Set(value, GetArena());
}
inline std::string* CreateAmStmt::_internal_mutable_amname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.amname_.Mutable( GetArena());
}
inline std::string* CreateAmStmt::release_amname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateAmStmt.amname)
  return _impl_.amname_.Release();
}
inline void CreateAmStmt::set_allocated_amname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.amname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.amname_.IsDefault()) {
          _impl_.amname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_handler_name().size();
}
inline int CreateAmStmt::handler_name_size() const {
  return _internal_handler_name_size();
}
inline void CreateAmStmt::clear_handler_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.handler_name_.Clear();
}
inline ::pg_query::Node* CreateAmStmt::mutable_handler_name(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateAmStmt.handler_name)
  return _internal_mutable_handler_name()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateAmStmt::mutable_handler_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateAmStmt.handler_name)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_handler_name();
}
inline const ::pg_query::Node& CreateAmStmt::handler_name(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateAmStmt.handler_name)
  return _internal_handler_name().Get(index);
}
inline ::pg_query::Node* CreateAmStmt::add_handler_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_handler_name()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateAmStmt.handler_name)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateAmStmt::handler_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateAmStmt.handler_name)
  return _internal_handler_name();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateAmStmt::_internal_handler_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.handler_name_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateAmStmt::_internal_mutable_handler_name() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.handler_name_;
}

// string amtype = 3 [json_name = "amtype"];
inline void CreateAmStmt::clear_amtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.amtype_.ClearToEmpty();
}
inline const std::string& CreateAmStmt::amtype() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateAmStmt.amtype)
  return _internal_amtype();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateAmStmt::set_amtype(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.amtype_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateAmStmt.amtype)
}
inline std::string* CreateAmStmt::mutable_amtype() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_amtype();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateAmStmt.amtype)
  return _s;
}
inline const std::string& CreateAmStmt::_internal_amtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.amtype_.Get();
}
inline void CreateAmStmt::_internal_set_amtype(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.amtype_.Set(value, GetArena());
}
inline std::string* CreateAmStmt::_internal_mutable_amtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.amtype_.Mutable( GetArena());
}
inline std::string* CreateAmStmt::release_amtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateAmStmt.amtype)
  return _impl_.amtype_.Release();
}
inline void CreateAmStmt::set_allocated_amtype(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.amtype_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.amtype_.IsDefault()) {
          _impl_.amtype_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateAmStmt.amtype)
}

// -------------------------------------------------------------------

// CreateTrigStmt

// bool replace = 1 [json_name = "replace"];
inline void CreateTrigStmt::clear_replace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.replace_ = false;
}
inline bool CreateTrigStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.replace)
  return _internal_replace();
}
inline void CreateTrigStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.replace)
}
inline bool CreateTrigStmt::_internal_replace() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.replace_;
}
inline void CreateTrigStmt::_internal_set_replace(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.replace_ = value;
}

// bool isconstraint = 2 [json_name = "isconstraint"];
inline void CreateTrigStmt::clear_isconstraint() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.isconstraint_ = false;
}
inline bool CreateTrigStmt::isconstraint() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.isconstraint)
  return _internal_isconstraint();
}
inline void CreateTrigStmt::set_isconstraint(bool value) {
  _internal_set_isconstraint(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.isconstraint)
}
inline bool CreateTrigStmt::_internal_isconstraint() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.isconstraint_;
}
inline void CreateTrigStmt::_internal_set_isconstraint(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.isconstraint_ = value;
}

// string trigname = 3 [json_name = "trigname"];
inline void CreateTrigStmt::clear_trigname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.trigname_.ClearToEmpty();
}
inline const std::string& CreateTrigStmt::trigname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.trigname)
  return _internal_trigname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateTrigStmt::set_trigname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.trigname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.trigname)
}
inline std::string* CreateTrigStmt::mutable_trigname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_trigname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.trigname)
  return _s;
}
inline const std::string& CreateTrigStmt::_internal_trigname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.trigname_.Get();
}
inline void CreateTrigStmt::_internal_set_trigname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.trigname_.Set(value, GetArena());
}
inline std::string* CreateTrigStmt::_internal_mutable_trigname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.trigname_.Mutable( GetArena());
}
inline std::string* CreateTrigStmt::release_trigname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTrigStmt.trigname)
  return _impl_.trigname_.Release();
}
inline void CreateTrigStmt::set_allocated_trigname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.trigname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.trigname_.IsDefault()) {
          _impl_.trigname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTrigStmt.trigname)
}

// .pg_query.RangeVar relation = 4 [json_name = "relation"];
inline bool CreateTrigStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void CreateTrigStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& CreateTrigStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CreateTrigStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.relation)
  return _internal_relation();
}
inline void CreateTrigStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTrigStmt.relation)
}
inline ::pg_query::RangeVar* CreateTrigStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* CreateTrigStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTrigStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CreateTrigStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* CreateTrigStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.relation)
  return _msg;
}
inline void CreateTrigStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTrigStmt.relation)
}

// repeated .pg_query.Node funcname = 5 [json_name = "funcname"];
inline int CreateTrigStmt::_internal_funcname_size() const {
  return _internal_funcname().size();
}
inline int CreateTrigStmt::funcname_size() const {
  return _internal_funcname_size();
}
inline void CreateTrigStmt::clear_funcname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funcname_.Clear();
}
inline ::pg_query::Node* CreateTrigStmt::mutable_funcname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.funcname)
  return _internal_mutable_funcname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateTrigStmt::mutable_funcname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTrigStmt.funcname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_funcname();
}
inline const ::pg_query::Node& CreateTrigStmt::funcname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.funcname)
  return _internal_funcname().Get(index);
}
inline ::pg_query::Node* CreateTrigStmt::add_funcname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_funcname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateTrigStmt.funcname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateTrigStmt::funcname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateTrigStmt.funcname)
  return _internal_funcname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateTrigStmt::_internal_funcname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funcname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateTrigStmt::_internal_mutable_funcname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.funcname_;
}

// repeated .pg_query.Node args = 6 [json_name = "args"];
inline int CreateTrigStmt::_internal_args_size() const {
  return _internal_args().size();
}
inline int CreateTrigStmt::args_size() const {
  return _internal_args_size();
}
inline void CreateTrigStmt::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* CreateTrigStmt::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateTrigStmt::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTrigStmt.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& CreateTrigStmt::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* CreateTrigStmt::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateTrigStmt.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateTrigStmt::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateTrigStmt.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateTrigStmt::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateTrigStmt::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// bool row = 7 [json_name = "row"];
inline void CreateTrigStmt::clear_row() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.row_ = false;
}
inline bool CreateTrigStmt::row() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.row)
  return _internal_row();
}
inline void CreateTrigStmt::set_row(bool value) {
  _internal_set_row(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.row)
}
inline bool CreateTrigStmt::_internal_row() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.row_;
}
inline void CreateTrigStmt::_internal_set_row(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.row_ = value;
}

// int32 timing = 8 [json_name = "timing"];
inline void CreateTrigStmt::clear_timing() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.timing_ = 0;
}
inline ::int32_t CreateTrigStmt::timing() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.timing)
  return _internal_timing();
}
inline void CreateTrigStmt::set_timing(::int32_t value) {
  _internal_set_timing(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.timing)
}
inline ::int32_t CreateTrigStmt::_internal_timing() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.timing_;
}
inline void CreateTrigStmt::_internal_set_timing(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.timing_ = value;
}

// int32 events = 9 [json_name = "events"];
inline void CreateTrigStmt::clear_events() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.events_ = 0;
}
inline ::int32_t CreateTrigStmt::events() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.events)
  return _internal_events();
}
inline void CreateTrigStmt::set_events(::int32_t value) {
  _internal_set_events(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.events)
}
inline ::int32_t CreateTrigStmt::_internal_events() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.events_;
}
inline void CreateTrigStmt::_internal_set_events(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.events_ = value;
}

// repeated .pg_query.Node columns = 10 [json_name = "columns"];
inline int CreateTrigStmt::_internal_columns_size() const {
  return _internal_columns().size();
}
inline int CreateTrigStmt::columns_size() const {
  return _internal_columns_size();
}
inline void CreateTrigStmt::clear_columns() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.columns_.Clear();
}
inline ::pg_query::Node* CreateTrigStmt::mutable_columns(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.columns)
  return _internal_mutable_columns()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateTrigStmt::mutable_columns()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTrigStmt.columns)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_columns();
}
inline const ::pg_query::Node& CreateTrigStmt::columns(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.columns)
  return _internal_columns().Get(index);
}
inline ::pg_query::Node* CreateTrigStmt::add_columns() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_columns()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateTrigStmt.columns)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateTrigStmt::columns() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateTrigStmt.columns)
  return _internal_columns();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateTrigStmt::_internal_columns() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.columns_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateTrigStmt::_internal_mutable_columns() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.columns_;
}

// .pg_query.Node when_clause = 11 [json_name = "whenClause"];
inline bool CreateTrigStmt::has_when_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.when_clause_ != nullptr);
  return value;
}
inline void CreateTrigStmt::clear_when_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.when_clause_ != nullptr) _impl_.when_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& CreateTrigStmt::_internal_when_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.when_clause_);
  }
  _impl_.when_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTrigStmt.when_clause)
}
inline ::pg_query::Node* CreateTrigStmt::release_when_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.when_clause_;
  _impl_.when_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CreateTrigStmt::unsafe_arena_release_when_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTrigStmt.when_clause)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.when_clause_;
  _impl_.when_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CreateTrigStmt::_internal_mutable_when_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.when_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.when_clause_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.when_clause_;
}
inline ::pg_query::Node* CreateTrigStmt::mutable_when_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_when_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.when_clause)
  return _msg;
}
inline void CreateTrigStmt::set_allocated_when_clause(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.when_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.when_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTrigStmt.when_clause)
}

// repeated .pg_query.Node transition_rels = 12 [json_name = "transitionRels"];
inline int CreateTrigStmt::_internal_transition_rels_size() const {
  return _internal_transition_rels().size();
}
inline int CreateTrigStmt::transition_rels_size() const {
  return _internal_transition_rels_size();
}
inline void CreateTrigStmt::clear_transition_rels() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.transition_rels_.Clear();
}
inline ::pg_query::Node* CreateTrigStmt::mutable_transition_rels(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.transition_rels)
  return _internal_mutable_transition_rels()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateTrigStmt::mutable_transition_rels()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTrigStmt.transition_rels)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_transition_rels();
}
inline const ::pg_query::Node& CreateTrigStmt::transition_rels(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.transition_rels)
  return _internal_transition_rels().Get(index);
}
inline ::pg_query::Node* CreateTrigStmt::add_transition_rels() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_transition_rels()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateTrigStmt.transition_rels)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateTrigStmt::transition_rels() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateTrigStmt.transition_rels)
  return _internal_transition_rels();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateTrigStmt::_internal_transition_rels() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.transition_rels_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateTrigStmt::_internal_mutable_transition_rels() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.transition_rels_;
}

// bool deferrable = 13 [json_name = "deferrable"];
inline void CreateTrigStmt::clear_deferrable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.deferrable_ = false;
}
inline bool CreateTrigStmt::deferrable() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.deferrable)
  return _internal_deferrable();
}
inline void CreateTrigStmt::set_deferrable(bool value) {
  _internal_set_deferrable(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.deferrable)
}
inline bool CreateTrigStmt::_internal_deferrable() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.deferrable_;
}
inline void CreateTrigStmt::_internal_set_deferrable(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.deferrable_ = value;
}

// bool initdeferred = 14 [json_name = "initdeferred"];
inline void CreateTrigStmt::clear_initdeferred() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.initdeferred_ = false;
}
inline bool CreateTrigStmt::initdeferred() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.initdeferred)
  return _internal_initdeferred();
}
inline void CreateTrigStmt::set_initdeferred(bool value) {
  _internal_set_initdeferred(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.initdeferred)
}
inline bool CreateTrigStmt::_internal_initdeferred() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.initdeferred_;
}
inline void CreateTrigStmt::_internal_set_initdeferred(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.initdeferred_ = value;
}

// .pg_query.RangeVar constrrel = 15 [json_name = "constrrel"];
inline bool CreateTrigStmt::has_constrrel() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.constrrel_ != nullptr);
  return value;
}
inline void CreateTrigStmt::clear_constrrel() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.constrrel_ != nullptr) _impl_.constrrel_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::RangeVar& CreateTrigStmt::_internal_constrrel() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.constrrel_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CreateTrigStmt::constrrel() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.constrrel)
  return _internal_constrrel();
}
inline void CreateTrigStmt::unsafe_arena_set_allocated_constrrel(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.constrrel_);
  }
  _impl_.constrrel_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTrigStmt.constrrel)
}
inline ::pg_query::RangeVar* CreateTrigStmt::release_constrrel() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::RangeVar* released = _impl_.constrrel_;
  _impl_.constrrel_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* CreateTrigStmt::unsafe_arena_release_constrrel() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTrigStmt.constrrel)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::RangeVar* temp = _impl_.constrrel_;
  _impl_.constrrel_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CreateTrigStmt::_internal_mutable_constrrel() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.constrrel_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.constrrel_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.constrrel_;
}
inline ::pg_query::RangeVar* CreateTrigStmt::mutable_constrrel() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_constrrel();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.constrrel)
  return _msg;
}
inline void CreateTrigStmt::set_allocated_constrrel(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.constrrel_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.constrrel_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTrigStmt.constrrel)
}

// -------------------------------------------------------------------

// CreateEventTrigStmt

// string trigname = 1 [json_name = "trigname"];
inline void CreateEventTrigStmt::clear_trigname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.trigname_.ClearToEmpty();
}
inline const std::string& CreateEventTrigStmt::trigname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateEventTrigStmt.trigname)
  return _internal_trigname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateEventTrigStmt::set_trigname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.trigname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateEventTrigStmt.trigname)
}
inline std::string* CreateEventTrigStmt::mutable_trigname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_trigname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateEventTrigStmt.trigname)
  return _s;
}
inline const std::string& CreateEventTrigStmt::_internal_trigname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.trigname_.Get();
}
inline void CreateEventTrigStmt::_internal_set_trigname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.trigname_.Set(value, GetArena());
}
inline std::string* CreateEventTrigStmt::_internal_mutable_trigname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.trigname_.Mutable( GetArena());
}
inline std::string* CreateEventTrigStmt::release_trigname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateEventTrigStmt.trigname)
  return _impl_.trigname_.Release();
}
inline void CreateEventTrigStmt::set_allocated_trigname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.trigname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.trigname_.IsDefault()) {
          _impl_.trigname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateEventTrigStmt.trigname)
}

// string eventname = 2 [json_name = "eventname"];
inline void CreateEventTrigStmt::clear_eventname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.eventname_.ClearToEmpty();
}
inline const std::string& CreateEventTrigStmt::eventname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateEventTrigStmt.eventname)
  return _internal_eventname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateEventTrigStmt::set_eventname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.eventname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateEventTrigStmt.eventname)
}
inline std::string* CreateEventTrigStmt::mutable_eventname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_eventname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateEventTrigStmt.eventname)
  return _s;
}
inline const std::string& CreateEventTrigStmt::_internal_eventname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.eventname_.Get();
}
inline void CreateEventTrigStmt::_internal_set_eventname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.eventname_.Set(value, GetArena());
}
inline std::string* CreateEventTrigStmt::_internal_mutable_eventname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.eventname_.Mutable( GetArena());
}
inline std::string* CreateEventTrigStmt::release_eventname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateEventTrigStmt.eventname)
  return _impl_.eventname_.Release();
}
inline void CreateEventTrigStmt::set_allocated_eventname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.eventname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.eventname_.IsDefault()) {
          _impl_.eventname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_whenclause().size();
}
inline int CreateEventTrigStmt::whenclause_size() const {
  return _internal_whenclause_size();
}
inline void CreateEventTrigStmt::clear_whenclause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.whenclause_.Clear();
}
inline ::pg_query::Node* CreateEventTrigStmt::mutable_whenclause(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateEventTrigStmt.whenclause)
  return _internal_mutable_whenclause()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateEventTrigStmt::mutable_whenclause()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateEventTrigStmt.whenclause)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_whenclause();
}
inline const ::pg_query::Node& CreateEventTrigStmt::whenclause(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateEventTrigStmt.whenclause)
  return _internal_whenclause().Get(index);
}
inline ::pg_query::Node* CreateEventTrigStmt::add_whenclause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_whenclause()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateEventTrigStmt.whenclause)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateEventTrigStmt::whenclause() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateEventTrigStmt.whenclause)
  return _internal_whenclause();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateEventTrigStmt::_internal_whenclause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.whenclause_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateEventTrigStmt::_internal_mutable_whenclause() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.whenclause_;
}

// repeated .pg_query.Node funcname = 4 [json_name = "funcname"];
inline int CreateEventTrigStmt::_internal_funcname_size() const {
  return _internal_funcname().size();
}
inline int CreateEventTrigStmt::funcname_size() const {
  return _internal_funcname_size();
}
inline void CreateEventTrigStmt::clear_funcname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funcname_.Clear();
}
inline ::pg_query::Node* CreateEventTrigStmt::mutable_funcname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateEventTrigStmt.funcname)
  return _internal_mutable_funcname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateEventTrigStmt::mutable_funcname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateEventTrigStmt.funcname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_funcname();
}
inline const ::pg_query::Node& CreateEventTrigStmt::funcname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateEventTrigStmt.funcname)
  return _internal_funcname().Get(index);
}
inline ::pg_query::Node* CreateEventTrigStmt::add_funcname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_funcname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateEventTrigStmt.funcname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateEventTrigStmt::funcname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateEventTrigStmt.funcname)
  return _internal_funcname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateEventTrigStmt::_internal_funcname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funcname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateEventTrigStmt::_internal_mutable_funcname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.funcname_;
}

// -------------------------------------------------------------------

// AlterEventTrigStmt

// string trigname = 1 [json_name = "trigname"];
inline void AlterEventTrigStmt::clear_trigname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.trigname_.ClearToEmpty();
}
inline const std::string& AlterEventTrigStmt::trigname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterEventTrigStmt.trigname)
  return _internal_trigname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterEventTrigStmt::set_trigname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.trigname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterEventTrigStmt.trigname)
}
inline std::string* AlterEventTrigStmt::mutable_trigname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_trigname();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterEventTrigStmt.trigname)
  return _s;
}
inline const std::string& AlterEventTrigStmt::_internal_trigname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.trigname_.Get();
}
inline void AlterEventTrigStmt::_internal_set_trigname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.trigname_.Set(value, GetArena());
}
inline std::string* AlterEventTrigStmt::_internal_mutable_trigname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.trigname_.Mutable( GetArena());
}
inline std::string* AlterEventTrigStmt::release_trigname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterEventTrigStmt.trigname)
  return _impl_.trigname_.Release();
}
inline void AlterEventTrigStmt::set_allocated_trigname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.trigname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.trigname_.IsDefault()) {
          _impl_.trigname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterEventTrigStmt.trigname)
}

// string tgenabled = 2 [json_name = "tgenabled"];
inline void AlterEventTrigStmt::clear_tgenabled() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tgenabled_.ClearToEmpty();
}
inline const std::string& AlterEventTrigStmt::tgenabled() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterEventTrigStmt.tgenabled)
  return _internal_tgenabled();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterEventTrigStmt::set_tgenabled(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.tgenabled_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterEventTrigStmt.tgenabled)
}
inline std::string* AlterEventTrigStmt::mutable_tgenabled() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_tgenabled();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterEventTrigStmt.tgenabled)
  return _s;
}
inline const std::string& AlterEventTrigStmt::_internal_tgenabled() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.tgenabled_.Get();
}
inline void AlterEventTrigStmt::_internal_set_tgenabled(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.tgenabled_.Set(value, GetArena());
}
inline std::string* AlterEventTrigStmt::_internal_mutable_tgenabled() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.tgenabled_.Mutable( GetArena());
}
inline std::string* AlterEventTrigStmt::release_tgenabled() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterEventTrigStmt.tgenabled)
  return _impl_.tgenabled_.Release();
}
inline void AlterEventTrigStmt::set_allocated_tgenabled(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tgenabled_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.tgenabled_.IsDefault()) {
          _impl_.tgenabled_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterEventTrigStmt.tgenabled)
}

// -------------------------------------------------------------------

// CreatePLangStmt

// bool replace = 1 [json_name = "replace"];
inline void CreatePLangStmt::clear_replace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.replace_ = false;
}
inline bool CreatePLangStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.replace)
  return _internal_replace();
}
inline void CreatePLangStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatePLangStmt.replace)
}
inline bool CreatePLangStmt::_internal_replace() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.replace_;
}
inline void CreatePLangStmt::_internal_set_replace(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.replace_ = value;
}

// string plname = 2 [json_name = "plname"];
inline void CreatePLangStmt::clear_plname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.plname_.ClearToEmpty();
}
inline const std::string& CreatePLangStmt::plname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.plname)
  return _internal_plname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreatePLangStmt::set_plname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.plname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreatePLangStmt.plname)
}
inline std::string* CreatePLangStmt::mutable_plname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_plname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePLangStmt.plname)
  return _s;
}
inline const std::string& CreatePLangStmt::_internal_plname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.plname_.Get();
}
inline void CreatePLangStmt::_internal_set_plname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.plname_.Set(value, GetArena());
}
inline std::string* CreatePLangStmt::_internal_mutable_plname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.plname_.Mutable( GetArena());
}
inline std::string* CreatePLangStmt::release_plname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreatePLangStmt.plname)
  return _impl_.plname_.Release();
}
inline void CreatePLangStmt::set_allocated_plname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.plname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.plname_.IsDefault()) {
          _impl_.plname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_plhandler().size();
}
inline int CreatePLangStmt::plhandler_size() const {
  return _internal_plhandler_size();
}
inline void CreatePLangStmt::clear_plhandler() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.plhandler_.Clear();
}
inline ::pg_query::Node* CreatePLangStmt::mutable_plhandler(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePLangStmt.plhandler)
  return _internal_mutable_plhandler()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreatePLangStmt::mutable_plhandler()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePLangStmt.plhandler)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_plhandler();
}
inline const ::pg_query::Node& CreatePLangStmt::plhandler(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.plhandler)
  return _internal_plhandler().Get(index);
}
inline ::pg_query::Node* CreatePLangStmt::add_plhandler() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_plhandler()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreatePLangStmt.plhandler)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreatePLangStmt::plhandler() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreatePLangStmt.plhandler)
  return _internal_plhandler();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreatePLangStmt::_internal_plhandler() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.plhandler_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreatePLangStmt::_internal_mutable_plhandler() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.plhandler_;
}

// repeated .pg_query.Node plinline = 4 [json_name = "plinline"];
inline int CreatePLangStmt::_internal_plinline_size() const {
  return _internal_plinline().size();
}
inline int CreatePLangStmt::plinline_size() const {
  return _internal_plinline_size();
}
inline void CreatePLangStmt::clear_plinline() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.plinline_.Clear();
}
inline ::pg_query::Node* CreatePLangStmt::mutable_plinline(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePLangStmt.plinline)
  return _internal_mutable_plinline()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreatePLangStmt::mutable_plinline()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePLangStmt.plinline)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_plinline();
}
inline const ::pg_query::Node& CreatePLangStmt::plinline(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.plinline)
  return _internal_plinline().Get(index);
}
inline ::pg_query::Node* CreatePLangStmt::add_plinline() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_plinline()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreatePLangStmt.plinline)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreatePLangStmt::plinline() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreatePLangStmt.plinline)
  return _internal_plinline();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreatePLangStmt::_internal_plinline() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.plinline_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreatePLangStmt::_internal_mutable_plinline() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.plinline_;
}

// repeated .pg_query.Node plvalidator = 5 [json_name = "plvalidator"];
inline int CreatePLangStmt::_internal_plvalidator_size() const {
  return _internal_plvalidator().size();
}
inline int CreatePLangStmt::plvalidator_size() const {
  return _internal_plvalidator_size();
}
inline void CreatePLangStmt::clear_plvalidator() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.plvalidator_.Clear();
}
inline ::pg_query::Node* CreatePLangStmt::mutable_plvalidator(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePLangStmt.plvalidator)
  return _internal_mutable_plvalidator()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreatePLangStmt::mutable_plvalidator()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePLangStmt.plvalidator)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_plvalidator();
}
inline const ::pg_query::Node& CreatePLangStmt::plvalidator(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.plvalidator)
  return _internal_plvalidator().Get(index);
}
inline ::pg_query::Node* CreatePLangStmt::add_plvalidator() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_plvalidator()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreatePLangStmt.plvalidator)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreatePLangStmt::plvalidator() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreatePLangStmt.plvalidator)
  return _internal_plvalidator();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreatePLangStmt::_internal_plvalidator() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.plvalidator_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreatePLangStmt::_internal_mutable_plvalidator() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.plvalidator_;
}

// bool pltrusted = 6 [json_name = "pltrusted"];
inline void CreatePLangStmt::clear_pltrusted() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.pltrusted_ = false;
}
inline bool CreatePLangStmt::pltrusted() const {
  // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.pltrusted)
  return _internal_pltrusted();
}
inline void CreatePLangStmt::set_pltrusted(bool value) {
  _internal_set_pltrusted(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatePLangStmt.pltrusted)
}
inline bool CreatePLangStmt::_internal_pltrusted() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.pltrusted_;
}
inline void CreatePLangStmt::_internal_set_pltrusted(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.pltrusted_ = value;
}

// -------------------------------------------------------------------

// CreateRoleStmt

// .pg_query.RoleStmtType stmt_type = 1 [json_name = "stmt_type"];
inline void CreateRoleStmt::clear_stmt_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stmt_type_ = 0;
}
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::set_stmt_type(::pg_query::RoleStmtType value) {
  _internal_set_stmt_type(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateRoleStmt.stmt_type)
}
inline ::pg_query::RoleStmtType CreateRoleStmt::_internal_stmt_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::RoleStmtType>(_impl_.stmt_type_);
}
inline void CreateRoleStmt::_internal_set_stmt_type(::pg_query::RoleStmtType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.stmt_type_ = value;
}

// string role = 2 [json_name = "role"];
inline void CreateRoleStmt::clear_role() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.role_.ClearToEmpty();
}
inline const std::string& CreateRoleStmt::role() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateRoleStmt.role)
  return _internal_role();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateRoleStmt::set_role(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.role_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateRoleStmt.role)
}
inline std::string* CreateRoleStmt::mutable_role() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_role();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateRoleStmt.role)
  return _s;
}
inline const std::string& CreateRoleStmt::_internal_role() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.role_.Get();
}
inline void CreateRoleStmt::_internal_set_role(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.role_.Set(value, GetArena());
}
inline std::string* CreateRoleStmt::_internal_mutable_role() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.role_.Mutable( GetArena());
}
inline std::string* CreateRoleStmt::release_role() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateRoleStmt.role)
  return _impl_.role_.Release();
}
inline void CreateRoleStmt::set_allocated_role(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.role_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.role_.IsDefault()) {
          _impl_.role_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int CreateRoleStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateRoleStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreateRoleStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateRoleStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateRoleStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateRoleStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreateRoleStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateRoleStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreateRoleStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateRoleStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateRoleStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateRoleStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateRoleStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateRoleStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// AlterRoleStmt

// .pg_query.RoleSpec role = 1 [json_name = "role"];
inline bool AlterRoleStmt::has_role() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.role_ != nullptr);
  return value;
}
inline void AlterRoleStmt::clear_role() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.role_ != nullptr) _impl_.role_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RoleSpec& AlterRoleStmt::_internal_role() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RoleSpec* p = _impl_.role_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& AlterRoleStmt::role() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterRoleStmt.role)
  return _internal_role();
}
inline void AlterRoleStmt::unsafe_arena_set_allocated_role(::pg_query::RoleSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.role_);
  }
  _impl_.role_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterRoleStmt.role)
}
inline ::pg_query::RoleSpec* AlterRoleStmt::release_role() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* released = _impl_.role_;
  _impl_.role_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RoleSpec* AlterRoleStmt::unsafe_arena_release_role() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterRoleStmt.role)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* temp = _impl_.role_;
  _impl_.role_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* AlterRoleStmt::_internal_mutable_role() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.role_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    _impl_.role_ = reinterpret_cast<::pg_query::RoleSpec*>(p);
  }
  return _impl_.role_;
}
inline ::pg_query::RoleSpec* AlterRoleStmt::mutable_role() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_role();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterRoleStmt.role)
  return _msg;
}
inline void AlterRoleStmt::set_allocated_role(::pg_query::RoleSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RoleSpec*>(_impl_.role_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RoleSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.role_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  // @@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 _internal_options().size();
}
inline int AlterRoleStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterRoleStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterRoleStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterRoleStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterRoleStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterRoleStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterRoleStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterRoleStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterRoleStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterRoleStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterRoleStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterRoleStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterRoleStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterRoleStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// int32 action = 3 [json_name = "action"];
inline void AlterRoleStmt::clear_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.action_ = 0;
}
inline ::int32_t AlterRoleStmt::action() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterRoleStmt.action)
  return _internal_action();
}
inline void AlterRoleStmt::set_action(::int32_t value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterRoleStmt.action)
}
inline ::int32_t AlterRoleStmt::_internal_action() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.action_;
}
inline void AlterRoleStmt::_internal_set_action(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.action_ = value;
}

// -------------------------------------------------------------------

// AlterRoleSetStmt

// .pg_query.RoleSpec role = 1 [json_name = "role"];
inline bool AlterRoleSetStmt::has_role() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.role_ != nullptr);
  return value;
}
inline void AlterRoleSetStmt::clear_role() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.role_ != nullptr) _impl_.role_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RoleSpec& AlterRoleSetStmt::_internal_role() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RoleSpec* p = _impl_.role_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& AlterRoleSetStmt::role() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterRoleSetStmt.role)
  return _internal_role();
}
inline void AlterRoleSetStmt::unsafe_arena_set_allocated_role(::pg_query::RoleSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.role_);
  }
  _impl_.role_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterRoleSetStmt.role)
}
inline ::pg_query::RoleSpec* AlterRoleSetStmt::release_role() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* released = _impl_.role_;
  _impl_.role_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RoleSpec* AlterRoleSetStmt::unsafe_arena_release_role() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterRoleSetStmt.role)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* temp = _impl_.role_;
  _impl_.role_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* AlterRoleSetStmt::_internal_mutable_role() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.role_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    _impl_.role_ = reinterpret_cast<::pg_query::RoleSpec*>(p);
  }
  return _impl_.role_;
}
inline ::pg_query::RoleSpec* AlterRoleSetStmt::mutable_role() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_role();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterRoleSetStmt.role)
  return _msg;
}
inline void AlterRoleSetStmt::set_allocated_role(::pg_query::RoleSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RoleSpec*>(_impl_.role_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RoleSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.role_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterRoleSetStmt.role)
}

// string database = 2 [json_name = "database"];
inline void AlterRoleSetStmt::clear_database() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.database_.ClearToEmpty();
}
inline const std::string& AlterRoleSetStmt::database() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterRoleSetStmt.database)
  return _internal_database();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterRoleSetStmt::set_database(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.database_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterRoleSetStmt.database)
}
inline std::string* AlterRoleSetStmt::mutable_database() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_database();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterRoleSetStmt.database)
  return _s;
}
inline const std::string& AlterRoleSetStmt::_internal_database() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.database_.Get();
}
inline void AlterRoleSetStmt::_internal_set_database(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.database_.Set(value, GetArena());
}
inline std::string* AlterRoleSetStmt::_internal_mutable_database() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.database_.Mutable( GetArena());
}
inline std::string* AlterRoleSetStmt::release_database() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterRoleSetStmt.database)
  return _impl_.database_.Release();
}
inline void AlterRoleSetStmt::set_allocated_database(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.database_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.database_.IsDefault()) {
          _impl_.database_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterRoleSetStmt.database)
}

// .pg_query.VariableSetStmt setstmt = 3 [json_name = "setstmt"];
inline bool AlterRoleSetStmt::has_setstmt() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.setstmt_ != nullptr);
  return value;
}
inline void AlterRoleSetStmt::clear_setstmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.setstmt_ != nullptr) _impl_.setstmt_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::VariableSetStmt& AlterRoleSetStmt::_internal_setstmt() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::VariableSetStmt* p = _impl_.setstmt_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::VariableSetStmt&>(::pg_query::_VariableSetStmt_default_instance_);
}
inline const ::pg_query::VariableSetStmt& AlterRoleSetStmt::setstmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterRoleSetStmt.setstmt)
  return _internal_setstmt();
}
inline void AlterRoleSetStmt::unsafe_arena_set_allocated_setstmt(::pg_query::VariableSetStmt* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.setstmt_);
  }
  _impl_.setstmt_ = reinterpret_cast<::pg_query::VariableSetStmt*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterRoleSetStmt.setstmt)
}
inline ::pg_query::VariableSetStmt* AlterRoleSetStmt::release_setstmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::VariableSetStmt* released = _impl_.setstmt_;
  _impl_.setstmt_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::VariableSetStmt* AlterRoleSetStmt::unsafe_arena_release_setstmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterRoleSetStmt.setstmt)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::VariableSetStmt* temp = _impl_.setstmt_;
  _impl_.setstmt_ = nullptr;
  return temp;
}
inline ::pg_query::VariableSetStmt* AlterRoleSetStmt::_internal_mutable_setstmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.setstmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::VariableSetStmt>(GetArena());
    _impl_.setstmt_ = reinterpret_cast<::pg_query::VariableSetStmt*>(p);
  }
  return _impl_.setstmt_;
}
inline ::pg_query::VariableSetStmt* AlterRoleSetStmt::mutable_setstmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::VariableSetStmt* _msg = _internal_mutable_setstmt();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterRoleSetStmt.setstmt)
  return _msg;
}
inline void AlterRoleSetStmt::set_allocated_setstmt(::pg_query::VariableSetStmt* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::VariableSetStmt*>(_impl_.setstmt_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::VariableSetStmt*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.setstmt_ = reinterpret_cast<::pg_query::VariableSetStmt*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterRoleSetStmt.setstmt)
}

// -------------------------------------------------------------------

// DropRoleStmt

// repeated .pg_query.Node roles = 1 [json_name = "roles"];
inline int DropRoleStmt::_internal_roles_size() const {
  return _internal_roles().size();
}
inline int DropRoleStmt::roles_size() const {
  return _internal_roles_size();
}
inline void DropRoleStmt::clear_roles() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.roles_.Clear();
}
inline ::pg_query::Node* DropRoleStmt::mutable_roles(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.DropRoleStmt.roles)
  return _internal_mutable_roles()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* DropRoleStmt::mutable_roles()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DropRoleStmt.roles)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_roles();
}
inline const ::pg_query::Node& DropRoleStmt::roles(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DropRoleStmt.roles)
  return _internal_roles().Get(index);
}
inline ::pg_query::Node* DropRoleStmt::add_roles() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_roles()->Add();
  // @@protoc_insertion_point(field_add:pg_query.DropRoleStmt.roles)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& DropRoleStmt::roles() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.DropRoleStmt.roles)
  return _internal_roles();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
DropRoleStmt::_internal_roles() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.roles_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
DropRoleStmt::_internal_mutable_roles() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.roles_;
}

// bool missing_ok = 2 [json_name = "missing_ok"];
inline void DropRoleStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool DropRoleStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.DropRoleStmt.missing_ok)
  return _internal_missing_ok();
}
inline void DropRoleStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.DropRoleStmt.missing_ok)
}
inline bool DropRoleStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void DropRoleStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// -------------------------------------------------------------------

// CreateSeqStmt

// .pg_query.RangeVar sequence = 1 [json_name = "sequence"];
inline bool CreateSeqStmt::has_sequence() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sequence_ != nullptr);
  return value;
}
inline void CreateSeqStmt::clear_sequence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.sequence_ != nullptr) _impl_.sequence_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& CreateSeqStmt::_internal_sequence() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.sequence_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CreateSeqStmt::sequence() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.sequence)
  return _internal_sequence();
}
inline void CreateSeqStmt::unsafe_arena_set_allocated_sequence(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sequence_);
  }
  _impl_.sequence_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateSeqStmt.sequence)
}
inline ::pg_query::RangeVar* CreateSeqStmt::release_sequence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.sequence_;
  _impl_.sequence_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* CreateSeqStmt::unsafe_arena_release_sequence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateSeqStmt.sequence)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.sequence_;
  _impl_.sequence_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CreateSeqStmt::_internal_mutable_sequence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.sequence_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.sequence_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.sequence_;
}
inline ::pg_query::RangeVar* CreateSeqStmt::mutable_sequence() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_sequence();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSeqStmt.sequence)
  return _msg;
}
inline void CreateSeqStmt::set_allocated_sequence(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.sequence_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.sequence_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@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 _internal_options().size();
}
inline int CreateSeqStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateSeqStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreateSeqStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSeqStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateSeqStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateSeqStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreateSeqStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreateSeqStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateSeqStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateSeqStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateSeqStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateSeqStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateSeqStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// uint32 owner_id = 3 [json_name = "ownerId"];
inline void CreateSeqStmt::clear_owner_id() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.owner_id_ = 0u;
}
inline ::uint32_t CreateSeqStmt::owner_id() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.owner_id)
  return _internal_owner_id();
}
inline void CreateSeqStmt::set_owner_id(::uint32_t value) {
  _internal_set_owner_id(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateSeqStmt.owner_id)
}
inline ::uint32_t CreateSeqStmt::_internal_owner_id() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.owner_id_;
}
inline void CreateSeqStmt::_internal_set_owner_id(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.owner_id_ = value;
}

// bool for_identity = 4 [json_name = "for_identity"];
inline void CreateSeqStmt::clear_for_identity() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.for_identity_ = false;
}
inline bool CreateSeqStmt::for_identity() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.for_identity)
  return _internal_for_identity();
}
inline void CreateSeqStmt::set_for_identity(bool value) {
  _internal_set_for_identity(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateSeqStmt.for_identity)
}
inline bool CreateSeqStmt::_internal_for_identity() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.for_identity_;
}
inline void CreateSeqStmt::_internal_set_for_identity(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.for_identity_ = value;
}

// bool if_not_exists = 5 [json_name = "if_not_exists"];
inline void CreateSeqStmt::clear_if_not_exists() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.if_not_exists_ = false;
}
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::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateSeqStmt.if_not_exists)
}
inline bool CreateSeqStmt::_internal_if_not_exists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.if_not_exists_;
}
inline void CreateSeqStmt::_internal_set_if_not_exists(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.if_not_exists_ = value;
}

// -------------------------------------------------------------------

// AlterSeqStmt

// .pg_query.RangeVar sequence = 1 [json_name = "sequence"];
inline bool AlterSeqStmt::has_sequence() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sequence_ != nullptr);
  return value;
}
inline void AlterSeqStmt::clear_sequence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.sequence_ != nullptr) _impl_.sequence_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& AlterSeqStmt::_internal_sequence() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.sequence_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& AlterSeqStmt::sequence() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterSeqStmt.sequence)
  return _internal_sequence();
}
inline void AlterSeqStmt::unsafe_arena_set_allocated_sequence(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sequence_);
  }
  _impl_.sequence_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterSeqStmt.sequence)
}
inline ::pg_query::RangeVar* AlterSeqStmt::release_sequence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.sequence_;
  _impl_.sequence_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* AlterSeqStmt::unsafe_arena_release_sequence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterSeqStmt.sequence)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.sequence_;
  _impl_.sequence_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* AlterSeqStmt::_internal_mutable_sequence() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.sequence_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.sequence_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.sequence_;
}
inline ::pg_query::RangeVar* AlterSeqStmt::mutable_sequence() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_sequence();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSeqStmt.sequence)
  return _msg;
}
inline void AlterSeqStmt::set_allocated_sequence(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.sequence_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.sequence_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@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 _internal_options().size();
}
inline int AlterSeqStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterSeqStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterSeqStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSeqStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterSeqStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterSeqStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterSeqStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterSeqStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterSeqStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterSeqStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterSeqStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterSeqStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterSeqStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterSeqStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// bool for_identity = 3 [json_name = "for_identity"];
inline void AlterSeqStmt::clear_for_identity() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.for_identity_ = false;
}
inline bool AlterSeqStmt::for_identity() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSeqStmt.for_identity)
  return _internal_for_identity();
}
inline void AlterSeqStmt::set_for_identity(bool value) {
  _internal_set_for_identity(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterSeqStmt.for_identity)
}
inline bool AlterSeqStmt::_internal_for_identity() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.for_identity_;
}
inline void AlterSeqStmt::_internal_set_for_identity(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.for_identity_ = value;
}

// bool missing_ok = 4 [json_name = "missing_ok"];
inline void AlterSeqStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool AlterSeqStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSeqStmt.missing_ok)
  return _internal_missing_ok();
}
inline void AlterSeqStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterSeqStmt.missing_ok)
}
inline bool AlterSeqStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void AlterSeqStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// -------------------------------------------------------------------

// DefineStmt

// .pg_query.ObjectType kind = 1 [json_name = "kind"];
inline void DefineStmt::clear_kind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.kind_ = 0;
}
inline ::pg_query::ObjectType DefineStmt::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.kind)
  return _internal_kind();
}
inline void DefineStmt::set_kind(::pg_query::ObjectType value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.DefineStmt.kind)
}
inline ::pg_query::ObjectType DefineStmt::_internal_kind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.kind_);
}
inline void DefineStmt::_internal_set_kind(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.kind_ = value;
}

// bool oldstyle = 2 [json_name = "oldstyle"];
inline void DefineStmt::clear_oldstyle() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.oldstyle_ = false;
}
inline bool DefineStmt::oldstyle() const {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.oldstyle)
  return _internal_oldstyle();
}
inline void DefineStmt::set_oldstyle(bool value) {
  _internal_set_oldstyle(value);
  // @@protoc_insertion_point(field_set:pg_query.DefineStmt.oldstyle)
}
inline bool DefineStmt::_internal_oldstyle() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.oldstyle_;
}
inline void DefineStmt::_internal_set_oldstyle(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.oldstyle_ = value;
}

// repeated .pg_query.Node defnames = 3 [json_name = "defnames"];
inline int DefineStmt::_internal_defnames_size() const {
  return _internal_defnames().size();
}
inline int DefineStmt::defnames_size() const {
  return _internal_defnames_size();
}
inline void DefineStmt::clear_defnames() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.defnames_.Clear();
}
inline ::pg_query::Node* DefineStmt::mutable_defnames(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.DefineStmt.defnames)
  return _internal_mutable_defnames()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* DefineStmt::mutable_defnames()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DefineStmt.defnames)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_defnames();
}
inline const ::pg_query::Node& DefineStmt::defnames(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.defnames)
  return _internal_defnames().Get(index);
}
inline ::pg_query::Node* DefineStmt::add_defnames() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_defnames()->Add();
  // @@protoc_insertion_point(field_add:pg_query.DefineStmt.defnames)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& DefineStmt::defnames() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.DefineStmt.defnames)
  return _internal_defnames();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
DefineStmt::_internal_defnames() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.defnames_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
DefineStmt::_internal_mutable_defnames() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.defnames_;
}

// repeated .pg_query.Node args = 4 [json_name = "args"];
inline int DefineStmt::_internal_args_size() const {
  return _internal_args().size();
}
inline int DefineStmt::args_size() const {
  return _internal_args_size();
}
inline void DefineStmt::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* DefineStmt::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.DefineStmt.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* DefineStmt::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DefineStmt.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& DefineStmt::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* DefineStmt::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.DefineStmt.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& DefineStmt::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.DefineStmt.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
DefineStmt::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
DefineStmt::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// repeated .pg_query.Node definition = 5 [json_name = "definition"];
inline int DefineStmt::_internal_definition_size() const {
  return _internal_definition().size();
}
inline int DefineStmt::definition_size() const {
  return _internal_definition_size();
}
inline void DefineStmt::clear_definition() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.definition_.Clear();
}
inline ::pg_query::Node* DefineStmt::mutable_definition(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.DefineStmt.definition)
  return _internal_mutable_definition()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* DefineStmt::mutable_definition()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DefineStmt.definition)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_definition();
}
inline const ::pg_query::Node& DefineStmt::definition(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.definition)
  return _internal_definition().Get(index);
}
inline ::pg_query::Node* DefineStmt::add_definition() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_definition()->Add();
  // @@protoc_insertion_point(field_add:pg_query.DefineStmt.definition)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& DefineStmt::definition() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.DefineStmt.definition)
  return _internal_definition();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
DefineStmt::_internal_definition() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.definition_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
DefineStmt::_internal_mutable_definition() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.definition_;
}

// bool if_not_exists = 6 [json_name = "if_not_exists"];
inline void DefineStmt::clear_if_not_exists() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.if_not_exists_ = false;
}
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::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.DefineStmt.if_not_exists)
}
inline bool DefineStmt::_internal_if_not_exists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.if_not_exists_;
}
inline void DefineStmt::_internal_set_if_not_exists(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.if_not_exists_ = value;
}

// bool replace = 7 [json_name = "replace"];
inline void DefineStmt::clear_replace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.replace_ = false;
}
inline bool DefineStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.DefineStmt.replace)
  return _internal_replace();
}
inline void DefineStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.DefineStmt.replace)
}
inline bool DefineStmt::_internal_replace() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.replace_;
}
inline void DefineStmt::_internal_set_replace(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.replace_ = value;
}

// -------------------------------------------------------------------

// CreateDomainStmt

// repeated .pg_query.Node domainname = 1 [json_name = "domainname"];
inline int CreateDomainStmt::_internal_domainname_size() const {
  return _internal_domainname().size();
}
inline int CreateDomainStmt::domainname_size() const {
  return _internal_domainname_size();
}
inline void CreateDomainStmt::clear_domainname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.domainname_.Clear();
}
inline ::pg_query::Node* CreateDomainStmt::mutable_domainname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateDomainStmt.domainname)
  return _internal_mutable_domainname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateDomainStmt::mutable_domainname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateDomainStmt.domainname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_domainname();
}
inline const ::pg_query::Node& CreateDomainStmt::domainname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateDomainStmt.domainname)
  return _internal_domainname().Get(index);
}
inline ::pg_query::Node* CreateDomainStmt::add_domainname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_domainname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateDomainStmt.domainname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateDomainStmt::domainname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateDomainStmt.domainname)
  return _internal_domainname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateDomainStmt::_internal_domainname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.domainname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateDomainStmt::_internal_mutable_domainname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.domainname_;
}

// .pg_query.TypeName type_name = 2 [json_name = "typeName"];
inline bool CreateDomainStmt::has_type_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.type_name_ != nullptr);
  return value;
}
inline void CreateDomainStmt::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.type_name_ != nullptr) _impl_.type_name_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::TypeName& CreateDomainStmt::_internal_type_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_name_);
  }
  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateDomainStmt.type_name)
}
inline ::pg_query::TypeName* CreateDomainStmt::release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* released = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* CreateDomainStmt::unsafe_arena_release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateDomainStmt.type_name)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* temp = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateDomainStmt::_internal_mutable_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.type_name_;
}
inline ::pg_query::TypeName* CreateDomainStmt::mutable_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_type_name();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateDomainStmt.type_name)
  return _msg;
}
inline void CreateDomainStmt::set_allocated_type_name(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.type_name_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateDomainStmt.type_name)
}

// .pg_query.CollateClause coll_clause = 3 [json_name = "collClause"];
inline bool CreateDomainStmt::has_coll_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.coll_clause_ != nullptr);
  return value;
}
inline void CreateDomainStmt::clear_coll_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.coll_clause_ != nullptr) _impl_.coll_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::CollateClause& CreateDomainStmt::_internal_coll_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::CollateClause* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.coll_clause_);
  }
  _impl_.coll_clause_ = reinterpret_cast<::pg_query::CollateClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateDomainStmt.coll_clause)
}
inline ::pg_query::CollateClause* CreateDomainStmt::release_coll_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::CollateClause* released = _impl_.coll_clause_;
  _impl_.coll_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::CollateClause* CreateDomainStmt::unsafe_arena_release_coll_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateDomainStmt.coll_clause)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::CollateClause* temp = _impl_.coll_clause_;
  _impl_.coll_clause_ = nullptr;
  return temp;
}
inline ::pg_query::CollateClause* CreateDomainStmt::_internal_mutable_coll_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.coll_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::CollateClause>(GetArena());
    _impl_.coll_clause_ = reinterpret_cast<::pg_query::CollateClause*>(p);
  }
  return _impl_.coll_clause_;
}
inline ::pg_query::CollateClause* CreateDomainStmt::mutable_coll_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::CollateClause* _msg = _internal_mutable_coll_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateDomainStmt.coll_clause)
  return _msg;
}
inline void CreateDomainStmt::set_allocated_coll_clause(::pg_query::CollateClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::CollateClause*>(_impl_.coll_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::CollateClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.coll_clause_ = reinterpret_cast<::pg_query::CollateClause*>(value);
  // @@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 _internal_constraints().size();
}
inline int CreateDomainStmt::constraints_size() const {
  return _internal_constraints_size();
}
inline void CreateDomainStmt::clear_constraints() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.constraints_.Clear();
}
inline ::pg_query::Node* CreateDomainStmt::mutable_constraints(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateDomainStmt.constraints)
  return _internal_mutable_constraints()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateDomainStmt::mutable_constraints()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateDomainStmt.constraints)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_constraints();
}
inline const ::pg_query::Node& CreateDomainStmt::constraints(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateDomainStmt.constraints)
  return _internal_constraints().Get(index);
}
inline ::pg_query::Node* CreateDomainStmt::add_constraints() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_constraints()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateDomainStmt.constraints)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateDomainStmt::constraints() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateDomainStmt.constraints)
  return _internal_constraints();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateDomainStmt::_internal_constraints() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.constraints_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateDomainStmt::_internal_mutable_constraints() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.constraints_;
}

// -------------------------------------------------------------------

// CreateOpClassStmt

// repeated .pg_query.Node opclassname = 1 [json_name = "opclassname"];
inline int CreateOpClassStmt::_internal_opclassname_size() const {
  return _internal_opclassname().size();
}
inline int CreateOpClassStmt::opclassname_size() const {
  return _internal_opclassname_size();
}
inline void CreateOpClassStmt::clear_opclassname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opclassname_.Clear();
}
inline ::pg_query::Node* CreateOpClassStmt::mutable_opclassname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.opclassname)
  return _internal_mutable_opclassname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateOpClassStmt::mutable_opclassname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassStmt.opclassname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_opclassname();
}
inline const ::pg_query::Node& CreateOpClassStmt::opclassname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.opclassname)
  return _internal_opclassname().Get(index);
}
inline ::pg_query::Node* CreateOpClassStmt::add_opclassname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_opclassname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateOpClassStmt.opclassname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateOpClassStmt::opclassname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateOpClassStmt.opclassname)
  return _internal_opclassname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateOpClassStmt::_internal_opclassname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opclassname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateOpClassStmt::_internal_mutable_opclassname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.opclassname_;
}

// repeated .pg_query.Node opfamilyname = 2 [json_name = "opfamilyname"];
inline int CreateOpClassStmt::_internal_opfamilyname_size() const {
  return _internal_opfamilyname().size();
}
inline int CreateOpClassStmt::opfamilyname_size() const {
  return _internal_opfamilyname_size();
}
inline void CreateOpClassStmt::clear_opfamilyname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opfamilyname_.Clear();
}
inline ::pg_query::Node* CreateOpClassStmt::mutable_opfamilyname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.opfamilyname)
  return _internal_mutable_opfamilyname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateOpClassStmt::mutable_opfamilyname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassStmt.opfamilyname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_opfamilyname();
}
inline const ::pg_query::Node& CreateOpClassStmt::opfamilyname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.opfamilyname)
  return _internal_opfamilyname().Get(index);
}
inline ::pg_query::Node* CreateOpClassStmt::add_opfamilyname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_opfamilyname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateOpClassStmt.opfamilyname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateOpClassStmt::opfamilyname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateOpClassStmt.opfamilyname)
  return _internal_opfamilyname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateOpClassStmt::_internal_opfamilyname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opfamilyname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateOpClassStmt::_internal_mutable_opfamilyname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.opfamilyname_;
}

// string amname = 3 [json_name = "amname"];
inline void CreateOpClassStmt::clear_amname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.amname_.ClearToEmpty();
}
inline const std::string& CreateOpClassStmt::amname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.amname)
  return _internal_amname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateOpClassStmt::set_amname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.amname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateOpClassStmt.amname)
}
inline std::string* CreateOpClassStmt::mutable_amname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_amname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.amname)
  return _s;
}
inline const std::string& CreateOpClassStmt::_internal_amname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.amname_.Get();
}
inline void CreateOpClassStmt::_internal_set_amname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.amname_.Set(value, GetArena());
}
inline std::string* CreateOpClassStmt::_internal_mutable_amname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.amname_.Mutable( GetArena());
}
inline std::string* CreateOpClassStmt::release_amname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateOpClassStmt.amname)
  return _impl_.amname_.Release();
}
inline void CreateOpClassStmt::set_allocated_amname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.amname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.amname_.IsDefault()) {
          _impl_.amname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateOpClassStmt.amname)
}

// .pg_query.TypeName datatype = 4 [json_name = "datatype"];
inline bool CreateOpClassStmt::has_datatype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.datatype_ != nullptr);
  return value;
}
inline void CreateOpClassStmt::clear_datatype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.datatype_ != nullptr) _impl_.datatype_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::TypeName& CreateOpClassStmt::_internal_datatype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.datatype_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& CreateOpClassStmt::datatype() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.datatype)
  return _internal_datatype();
}
inline void CreateOpClassStmt::unsafe_arena_set_allocated_datatype(::pg_query::TypeName* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.datatype_);
  }
  _impl_.datatype_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateOpClassStmt.datatype)
}
inline ::pg_query::TypeName* CreateOpClassStmt::release_datatype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* released = _impl_.datatype_;
  _impl_.datatype_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* CreateOpClassStmt::unsafe_arena_release_datatype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateOpClassStmt.datatype)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* temp = _impl_.datatype_;
  _impl_.datatype_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateOpClassStmt::_internal_mutable_datatype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.datatype_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.datatype_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.datatype_;
}
inline ::pg_query::TypeName* CreateOpClassStmt::mutable_datatype() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_datatype();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.datatype)
  return _msg;
}
inline void CreateOpClassStmt::set_allocated_datatype(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.datatype_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.datatype_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@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 _internal_items().size();
}
inline int CreateOpClassStmt::items_size() const {
  return _internal_items_size();
}
inline void CreateOpClassStmt::clear_items() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.items_.Clear();
}
inline ::pg_query::Node* CreateOpClassStmt::mutable_items(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.items)
  return _internal_mutable_items()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateOpClassStmt::mutable_items()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassStmt.items)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_items();
}
inline const ::pg_query::Node& CreateOpClassStmt::items(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.items)
  return _internal_items().Get(index);
}
inline ::pg_query::Node* CreateOpClassStmt::add_items() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_items()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateOpClassStmt.items)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateOpClassStmt::items() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateOpClassStmt.items)
  return _internal_items();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateOpClassStmt::_internal_items() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.items_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateOpClassStmt::_internal_mutable_items() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.items_;
}

// bool is_default = 6 [json_name = "isDefault"];
inline void CreateOpClassStmt::clear_is_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_default_ = false;
}
inline bool CreateOpClassStmt::is_default() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.is_default)
  return _internal_is_default();
}
inline void CreateOpClassStmt::set_is_default(bool value) {
  _internal_set_is_default(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateOpClassStmt.is_default)
}
inline bool CreateOpClassStmt::_internal_is_default() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_default_;
}
inline void CreateOpClassStmt::_internal_set_is_default(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_default_ = value;
}

// -------------------------------------------------------------------

// CreateOpClassItem

// int32 itemtype = 1 [json_name = "itemtype"];
inline void CreateOpClassItem::clear_itemtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.itemtype_ = 0;
}
inline ::int32_t CreateOpClassItem::itemtype() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.itemtype)
  return _internal_itemtype();
}
inline void CreateOpClassItem::set_itemtype(::int32_t value) {
  _internal_set_itemtype(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateOpClassItem.itemtype)
}
inline ::int32_t CreateOpClassItem::_internal_itemtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.itemtype_;
}
inline void CreateOpClassItem::_internal_set_itemtype(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.itemtype_ = value;
}

// .pg_query.ObjectWithArgs name = 2 [json_name = "name"];
inline bool CreateOpClassItem::has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.name_ != nullptr);
  return value;
}
inline void CreateOpClassItem::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.name_ != nullptr) _impl_.name_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::ObjectWithArgs& CreateOpClassItem::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::ObjectWithArgs* p = _impl_.name_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::ObjectWithArgs&>(::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& CreateOpClassItem::name() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.name)
  return _internal_name();
}
inline void CreateOpClassItem::unsafe_arena_set_allocated_name(::pg_query::ObjectWithArgs* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.name_);
  }
  _impl_.name_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateOpClassItem.name)
}
inline ::pg_query::ObjectWithArgs* CreateOpClassItem::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::ObjectWithArgs* released = _impl_.name_;
  _impl_.name_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::ObjectWithArgs* CreateOpClassItem::unsafe_arena_release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateOpClassItem.name)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::ObjectWithArgs* temp = _impl_.name_;
  _impl_.name_ = nullptr;
  return temp;
}
inline ::pg_query::ObjectWithArgs* CreateOpClassItem::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
    _impl_.name_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(p);
  }
  return _impl_.name_;
}
inline ::pg_query::ObjectWithArgs* CreateOpClassItem::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ObjectWithArgs* _msg = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassItem.name)
  return _msg;
}
inline void CreateOpClassItem::set_allocated_name(::pg_query::ObjectWithArgs* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::ObjectWithArgs*>(_impl_.name_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::ObjectWithArgs*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.name_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateOpClassItem.name)
}

// int32 number = 3 [json_name = "number"];
inline void CreateOpClassItem::clear_number() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.number_ = 0;
}
inline ::int32_t CreateOpClassItem::number() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.number)
  return _internal_number();
}
inline void CreateOpClassItem::set_number(::int32_t value) {
  _internal_set_number(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateOpClassItem.number)
}
inline ::int32_t CreateOpClassItem::_internal_number() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.number_;
}
inline void CreateOpClassItem::_internal_set_number(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.number_ = value;
}

// repeated .pg_query.Node order_family = 4 [json_name = "order_family"];
inline int CreateOpClassItem::_internal_order_family_size() const {
  return _internal_order_family().size();
}
inline int CreateOpClassItem::order_family_size() const {
  return _internal_order_family_size();
}
inline void CreateOpClassItem::clear_order_family() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.order_family_.Clear();
}
inline ::pg_query::Node* CreateOpClassItem::mutable_order_family(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassItem.order_family)
  return _internal_mutable_order_family()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateOpClassItem::mutable_order_family()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassItem.order_family)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_order_family();
}
inline const ::pg_query::Node& CreateOpClassItem::order_family(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.order_family)
  return _internal_order_family().Get(index);
}
inline ::pg_query::Node* CreateOpClassItem::add_order_family() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_order_family()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateOpClassItem.order_family)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateOpClassItem::order_family() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateOpClassItem.order_family)
  return _internal_order_family();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateOpClassItem::_internal_order_family() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.order_family_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateOpClassItem::_internal_mutable_order_family() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.order_family_;
}

// repeated .pg_query.Node class_args = 5 [json_name = "class_args"];
inline int CreateOpClassItem::_internal_class_args_size() const {
  return _internal_class_args().size();
}
inline int CreateOpClassItem::class_args_size() const {
  return _internal_class_args_size();
}
inline void CreateOpClassItem::clear_class_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.class_args_.Clear();
}
inline ::pg_query::Node* CreateOpClassItem::mutable_class_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassItem.class_args)
  return _internal_mutable_class_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateOpClassItem::mutable_class_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassItem.class_args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_class_args();
}
inline const ::pg_query::Node& CreateOpClassItem::class_args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.class_args)
  return _internal_class_args().Get(index);
}
inline ::pg_query::Node* CreateOpClassItem::add_class_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_class_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateOpClassItem.class_args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateOpClassItem::class_args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateOpClassItem.class_args)
  return _internal_class_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateOpClassItem::_internal_class_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.class_args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateOpClassItem::_internal_mutable_class_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.class_args_;
}

// .pg_query.TypeName storedtype = 6 [json_name = "storedtype"];
inline bool CreateOpClassItem::has_storedtype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.storedtype_ != nullptr);
  return value;
}
inline void CreateOpClassItem::clear_storedtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.storedtype_ != nullptr) _impl_.storedtype_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::TypeName& CreateOpClassItem::_internal_storedtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.storedtype_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& CreateOpClassItem::storedtype() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.storedtype)
  return _internal_storedtype();
}
inline void CreateOpClassItem::unsafe_arena_set_allocated_storedtype(::pg_query::TypeName* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.storedtype_);
  }
  _impl_.storedtype_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateOpClassItem.storedtype)
}
inline ::pg_query::TypeName* CreateOpClassItem::release_storedtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::TypeName* released = _impl_.storedtype_;
  _impl_.storedtype_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* CreateOpClassItem::unsafe_arena_release_storedtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateOpClassItem.storedtype)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::TypeName* temp = _impl_.storedtype_;
  _impl_.storedtype_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateOpClassItem::_internal_mutable_storedtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.storedtype_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.storedtype_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.storedtype_;
}
inline ::pg_query::TypeName* CreateOpClassItem::mutable_storedtype() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_storedtype();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassItem.storedtype)
  return _msg;
}
inline void CreateOpClassItem::set_allocated_storedtype(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.storedtype_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.storedtype_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateOpClassItem.storedtype)
}

// -------------------------------------------------------------------

// CreateOpFamilyStmt

// repeated .pg_query.Node opfamilyname = 1 [json_name = "opfamilyname"];
inline int CreateOpFamilyStmt::_internal_opfamilyname_size() const {
  return _internal_opfamilyname().size();
}
inline int CreateOpFamilyStmt::opfamilyname_size() const {
  return _internal_opfamilyname_size();
}
inline void CreateOpFamilyStmt::clear_opfamilyname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opfamilyname_.Clear();
}
inline ::pg_query::Node* CreateOpFamilyStmt::mutable_opfamilyname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpFamilyStmt.opfamilyname)
  return _internal_mutable_opfamilyname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateOpFamilyStmt::mutable_opfamilyname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpFamilyStmt.opfamilyname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_opfamilyname();
}
inline const ::pg_query::Node& CreateOpFamilyStmt::opfamilyname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpFamilyStmt.opfamilyname)
  return _internal_opfamilyname().Get(index);
}
inline ::pg_query::Node* CreateOpFamilyStmt::add_opfamilyname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_opfamilyname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateOpFamilyStmt.opfamilyname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateOpFamilyStmt::opfamilyname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateOpFamilyStmt.opfamilyname)
  return _internal_opfamilyname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateOpFamilyStmt::_internal_opfamilyname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opfamilyname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateOpFamilyStmt::_internal_mutable_opfamilyname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.opfamilyname_;
}

// string amname = 2 [json_name = "amname"];
inline void CreateOpFamilyStmt::clear_amname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.amname_.ClearToEmpty();
}
inline const std::string& CreateOpFamilyStmt::amname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateOpFamilyStmt.amname)
  return _internal_amname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateOpFamilyStmt::set_amname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.amname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateOpFamilyStmt.amname)
}
inline std::string* CreateOpFamilyStmt::mutable_amname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_amname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateOpFamilyStmt.amname)
  return _s;
}
inline const std::string& CreateOpFamilyStmt::_internal_amname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.amname_.Get();
}
inline void CreateOpFamilyStmt::_internal_set_amname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.amname_.Set(value, GetArena());
}
inline std::string* CreateOpFamilyStmt::_internal_mutable_amname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.amname_.Mutable( GetArena());
}
inline std::string* CreateOpFamilyStmt::release_amname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateOpFamilyStmt.amname)
  return _impl_.amname_.Release();
}
inline void CreateOpFamilyStmt::set_allocated_amname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.amname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.amname_.IsDefault()) {
          _impl_.amname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_opfamilyname().size();
}
inline int AlterOpFamilyStmt::opfamilyname_size() const {
  return _internal_opfamilyname_size();
}
inline void AlterOpFamilyStmt::clear_opfamilyname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.opfamilyname_.Clear();
}
inline ::pg_query::Node* AlterOpFamilyStmt::mutable_opfamilyname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOpFamilyStmt.opfamilyname)
  return _internal_mutable_opfamilyname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterOpFamilyStmt::mutable_opfamilyname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterOpFamilyStmt.opfamilyname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_opfamilyname();
}
inline const ::pg_query::Node& AlterOpFamilyStmt::opfamilyname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterOpFamilyStmt.opfamilyname)
  return _internal_opfamilyname().Get(index);
}
inline ::pg_query::Node* AlterOpFamilyStmt::add_opfamilyname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_opfamilyname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterOpFamilyStmt.opfamilyname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterOpFamilyStmt::opfamilyname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterOpFamilyStmt.opfamilyname)
  return _internal_opfamilyname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterOpFamilyStmt::_internal_opfamilyname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.opfamilyname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterOpFamilyStmt::_internal_mutable_opfamilyname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.opfamilyname_;
}

// string amname = 2 [json_name = "amname"];
inline void AlterOpFamilyStmt::clear_amname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.amname_.ClearToEmpty();
}
inline const std::string& AlterOpFamilyStmt::amname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterOpFamilyStmt.amname)
  return _internal_amname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterOpFamilyStmt::set_amname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.amname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterOpFamilyStmt.amname)
}
inline std::string* AlterOpFamilyStmt::mutable_amname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_amname();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOpFamilyStmt.amname)
  return _s;
}
inline const std::string& AlterOpFamilyStmt::_internal_amname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.amname_.Get();
}
inline void AlterOpFamilyStmt::_internal_set_amname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.amname_.Set(value, GetArena());
}
inline std::string* AlterOpFamilyStmt::_internal_mutable_amname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.amname_.Mutable( GetArena());
}
inline std::string* AlterOpFamilyStmt::release_amname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterOpFamilyStmt.amname)
  return _impl_.amname_.Release();
}
inline void AlterOpFamilyStmt::set_allocated_amname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.amname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.amname_.IsDefault()) {
          _impl_.amname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOpFamilyStmt.amname)
}

// bool is_drop = 3 [json_name = "isDrop"];
inline void AlterOpFamilyStmt::clear_is_drop() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_drop_ = false;
}
inline bool AlterOpFamilyStmt::is_drop() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterOpFamilyStmt.is_drop)
  return _internal_is_drop();
}
inline void AlterOpFamilyStmt::set_is_drop(bool value) {
  _internal_set_is_drop(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterOpFamilyStmt.is_drop)
}
inline bool AlterOpFamilyStmt::_internal_is_drop() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_drop_;
}
inline void AlterOpFamilyStmt::_internal_set_is_drop(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_drop_ = value;
}

// repeated .pg_query.Node items = 4 [json_name = "items"];
inline int AlterOpFamilyStmt::_internal_items_size() const {
  return _internal_items().size();
}
inline int AlterOpFamilyStmt::items_size() const {
  return _internal_items_size();
}
inline void AlterOpFamilyStmt::clear_items() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.items_.Clear();
}
inline ::pg_query::Node* AlterOpFamilyStmt::mutable_items(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOpFamilyStmt.items)
  return _internal_mutable_items()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterOpFamilyStmt::mutable_items()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterOpFamilyStmt.items)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_items();
}
inline const ::pg_query::Node& AlterOpFamilyStmt::items(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterOpFamilyStmt.items)
  return _internal_items().Get(index);
}
inline ::pg_query::Node* AlterOpFamilyStmt::add_items() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_items()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterOpFamilyStmt.items)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterOpFamilyStmt::items() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterOpFamilyStmt.items)
  return _internal_items();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterOpFamilyStmt::_internal_items() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.items_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterOpFamilyStmt::_internal_mutable_items() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.items_;
}

// -------------------------------------------------------------------

// DropStmt

// repeated .pg_query.Node objects = 1 [json_name = "objects"];
inline int DropStmt::_internal_objects_size() const {
  return _internal_objects().size();
}
inline int DropStmt::objects_size() const {
  return _internal_objects_size();
}
inline void DropStmt::clear_objects() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objects_.Clear();
}
inline ::pg_query::Node* DropStmt::mutable_objects(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.DropStmt.objects)
  return _internal_mutable_objects()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* DropStmt::mutable_objects()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DropStmt.objects)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_objects();
}
inline const ::pg_query::Node& DropStmt::objects(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DropStmt.objects)
  return _internal_objects().Get(index);
}
inline ::pg_query::Node* DropStmt::add_objects() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_objects()->Add();
  // @@protoc_insertion_point(field_add:pg_query.DropStmt.objects)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& DropStmt::objects() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.DropStmt.objects)
  return _internal_objects();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
DropStmt::_internal_objects() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.objects_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
DropStmt::_internal_mutable_objects() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.objects_;
}

// .pg_query.ObjectType remove_type = 2 [json_name = "removeType"];
inline void DropStmt::clear_remove_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.remove_type_ = 0;
}
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::set_remove_type(::pg_query::ObjectType value) {
  _internal_set_remove_type(value);
  // @@protoc_insertion_point(field_set:pg_query.DropStmt.remove_type)
}
inline ::pg_query::ObjectType DropStmt::_internal_remove_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.remove_type_);
}
inline void DropStmt::_internal_set_remove_type(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.remove_type_ = value;
}

// .pg_query.DropBehavior behavior = 3 [json_name = "behavior"];
inline void DropStmt::clear_behavior() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.behavior_ = 0;
}
inline ::pg_query::DropBehavior DropStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.DropStmt.behavior)
  return _internal_behavior();
}
inline void DropStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.DropStmt.behavior)
}
inline ::pg_query::DropBehavior DropStmt::_internal_behavior() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::DropBehavior>(_impl_.behavior_);
}
inline void DropStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.behavior_ = value;
}

// bool missing_ok = 4 [json_name = "missing_ok"];
inline void DropStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool DropStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.DropStmt.missing_ok)
  return _internal_missing_ok();
}
inline void DropStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.DropStmt.missing_ok)
}
inline bool DropStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void DropStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// bool concurrent = 5 [json_name = "concurrent"];
inline void DropStmt::clear_concurrent() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.concurrent_ = false;
}
inline bool DropStmt::concurrent() const {
  // @@protoc_insertion_point(field_get:pg_query.DropStmt.concurrent)
  return _internal_concurrent();
}
inline void DropStmt::set_concurrent(bool value) {
  _internal_set_concurrent(value);
  // @@protoc_insertion_point(field_set:pg_query.DropStmt.concurrent)
}
inline bool DropStmt::_internal_concurrent() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.concurrent_;
}
inline void DropStmt::_internal_set_concurrent(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.concurrent_ = value;
}

// -------------------------------------------------------------------

// TruncateStmt

// repeated .pg_query.Node relations = 1 [json_name = "relations"];
inline int TruncateStmt::_internal_relations_size() const {
  return _internal_relations().size();
}
inline int TruncateStmt::relations_size() const {
  return _internal_relations_size();
}
inline void TruncateStmt::clear_relations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relations_.Clear();
}
inline ::pg_query::Node* TruncateStmt::mutable_relations(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TruncateStmt.relations)
  return _internal_mutable_relations()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TruncateStmt::mutable_relations()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TruncateStmt.relations)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_relations();
}
inline const ::pg_query::Node& TruncateStmt::relations(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TruncateStmt.relations)
  return _internal_relations().Get(index);
}
inline ::pg_query::Node* TruncateStmt::add_relations() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_relations()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TruncateStmt.relations)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TruncateStmt::relations() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TruncateStmt.relations)
  return _internal_relations();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TruncateStmt::_internal_relations() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.relations_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TruncateStmt::_internal_mutable_relations() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.relations_;
}

// bool restart_seqs = 2 [json_name = "restart_seqs"];
inline void TruncateStmt::clear_restart_seqs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.restart_seqs_ = false;
}
inline bool TruncateStmt::restart_seqs() const {
  // @@protoc_insertion_point(field_get:pg_query.TruncateStmt.restart_seqs)
  return _internal_restart_seqs();
}
inline void TruncateStmt::set_restart_seqs(bool value) {
  _internal_set_restart_seqs(value);
  // @@protoc_insertion_point(field_set:pg_query.TruncateStmt.restart_seqs)
}
inline bool TruncateStmt::_internal_restart_seqs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.restart_seqs_;
}
inline void TruncateStmt::_internal_set_restart_seqs(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.restart_seqs_ = value;
}

// .pg_query.DropBehavior behavior = 3 [json_name = "behavior"];
inline void TruncateStmt::clear_behavior() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.behavior_ = 0;
}
inline ::pg_query::DropBehavior TruncateStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.TruncateStmt.behavior)
  return _internal_behavior();
}
inline void TruncateStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.TruncateStmt.behavior)
}
inline ::pg_query::DropBehavior TruncateStmt::_internal_behavior() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::DropBehavior>(_impl_.behavior_);
}
inline void TruncateStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.behavior_ = value;
}

// -------------------------------------------------------------------

// CommentStmt

// .pg_query.ObjectType objtype = 1 [json_name = "objtype"];
inline void CommentStmt::clear_objtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objtype_ = 0;
}
inline ::pg_query::ObjectType CommentStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.CommentStmt.objtype)
  return _internal_objtype();
}
inline void CommentStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.CommentStmt.objtype)
}
inline ::pg_query::ObjectType CommentStmt::_internal_objtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.objtype_);
}
inline void CommentStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.objtype_ = value;
}

// .pg_query.Node object = 2 [json_name = "object"];
inline bool CommentStmt::has_object() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.object_ != nullptr);
  return value;
}
inline void CommentStmt::clear_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.object_ != nullptr) _impl_.object_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CommentStmt::_internal_object() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CommentStmt::object() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CommentStmt.object)
  return _internal_object();
}
inline void CommentStmt::unsafe_arena_set_allocated_object(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.object_);
  }
  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CommentStmt.object)
}
inline ::pg_query::Node* CommentStmt::release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.object_;
  _impl_.object_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CommentStmt::unsafe_arena_release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CommentStmt.object)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.object_;
  _impl_.object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CommentStmt::_internal_mutable_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.object_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.object_;
}
inline ::pg_query::Node* CommentStmt::mutable_object() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_object();
  // @@protoc_insertion_point(field_mutable:pg_query.CommentStmt.object)
  return _msg;
}
inline void CommentStmt::set_allocated_object(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.object_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CommentStmt.object)
}

// string comment = 3 [json_name = "comment"];
inline void CommentStmt::clear_comment() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.comment_.ClearToEmpty();
}
inline const std::string& CommentStmt::comment() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CommentStmt.comment)
  return _internal_comment();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CommentStmt::set_comment(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.comment_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CommentStmt.comment)
}
inline std::string* CommentStmt::mutable_comment() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_comment();
  // @@protoc_insertion_point(field_mutable:pg_query.CommentStmt.comment)
  return _s;
}
inline const std::string& CommentStmt::_internal_comment() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.comment_.Get();
}
inline void CommentStmt::_internal_set_comment(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.comment_.Set(value, GetArena());
}
inline std::string* CommentStmt::_internal_mutable_comment() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.comment_.Mutable( GetArena());
}
inline std::string* CommentStmt::release_comment() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CommentStmt.comment)
  return _impl_.comment_.Release();
}
inline void CommentStmt::set_allocated_comment(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.comment_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.comment_.IsDefault()) {
          _impl_.comment_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CommentStmt.comment)
}

// -------------------------------------------------------------------

// SecLabelStmt

// .pg_query.ObjectType objtype = 1 [json_name = "objtype"];
inline void SecLabelStmt::clear_objtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objtype_ = 0;
}
inline ::pg_query::ObjectType SecLabelStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.SecLabelStmt.objtype)
  return _internal_objtype();
}
inline void SecLabelStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.SecLabelStmt.objtype)
}
inline ::pg_query::ObjectType SecLabelStmt::_internal_objtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.objtype_);
}
inline void SecLabelStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.objtype_ = value;
}

// .pg_query.Node object = 2 [json_name = "object"];
inline bool SecLabelStmt::has_object() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.object_ != nullptr);
  return value;
}
inline void SecLabelStmt::clear_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.object_ != nullptr) _impl_.object_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& SecLabelStmt::_internal_object() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& SecLabelStmt::object() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SecLabelStmt.object)
  return _internal_object();
}
inline void SecLabelStmt::unsafe_arena_set_allocated_object(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.object_);
  }
  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SecLabelStmt.object)
}
inline ::pg_query::Node* SecLabelStmt::release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.object_;
  _impl_.object_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* SecLabelStmt::unsafe_arena_release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SecLabelStmt.object)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.object_;
  _impl_.object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* SecLabelStmt::_internal_mutable_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.object_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.object_;
}
inline ::pg_query::Node* SecLabelStmt::mutable_object() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_object();
  // @@protoc_insertion_point(field_mutable:pg_query.SecLabelStmt.object)
  return _msg;
}
inline void SecLabelStmt::set_allocated_object(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.object_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.SecLabelStmt.object)
}

// string provider = 3 [json_name = "provider"];
inline void SecLabelStmt::clear_provider() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.provider_.ClearToEmpty();
}
inline const std::string& SecLabelStmt::provider() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SecLabelStmt.provider)
  return _internal_provider();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void SecLabelStmt::set_provider(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.provider_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.SecLabelStmt.provider)
}
inline std::string* SecLabelStmt::mutable_provider() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_provider();
  // @@protoc_insertion_point(field_mutable:pg_query.SecLabelStmt.provider)
  return _s;
}
inline const std::string& SecLabelStmt::_internal_provider() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.provider_.Get();
}
inline void SecLabelStmt::_internal_set_provider(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.provider_.Set(value, GetArena());
}
inline std::string* SecLabelStmt::_internal_mutable_provider() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.provider_.Mutable( GetArena());
}
inline std::string* SecLabelStmt::release_provider() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SecLabelStmt.provider)
  return _impl_.provider_.Release();
}
inline void SecLabelStmt::set_allocated_provider(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.provider_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.provider_.IsDefault()) {
          _impl_.provider_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.SecLabelStmt.provider)
}

// string label = 4 [json_name = "label"];
inline void SecLabelStmt::clear_label() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.label_.ClearToEmpty();
}
inline const std::string& SecLabelStmt::label() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.SecLabelStmt.label)
  return _internal_label();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void SecLabelStmt::set_label(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.label_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.SecLabelStmt.label)
}
inline std::string* SecLabelStmt::mutable_label() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_label();
  // @@protoc_insertion_point(field_mutable:pg_query.SecLabelStmt.label)
  return _s;
}
inline const std::string& SecLabelStmt::_internal_label() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.label_.Get();
}
inline void SecLabelStmt::_internal_set_label(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.label_.Set(value, GetArena());
}
inline std::string* SecLabelStmt::_internal_mutable_label() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.label_.Mutable( GetArena());
}
inline std::string* SecLabelStmt::release_label() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.SecLabelStmt.label)
  return _impl_.label_.Release();
}
inline void SecLabelStmt::set_allocated_label(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.label_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.label_.IsDefault()) {
          _impl_.label_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.SecLabelStmt.label)
}

// -------------------------------------------------------------------

// DeclareCursorStmt

// string portalname = 1 [json_name = "portalname"];
inline void DeclareCursorStmt::clear_portalname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.portalname_.ClearToEmpty();
}
inline const std::string& DeclareCursorStmt::portalname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DeclareCursorStmt.portalname)
  return _internal_portalname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DeclareCursorStmt::set_portalname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.portalname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.DeclareCursorStmt.portalname)
}
inline std::string* DeclareCursorStmt::mutable_portalname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_portalname();
  // @@protoc_insertion_point(field_mutable:pg_query.DeclareCursorStmt.portalname)
  return _s;
}
inline const std::string& DeclareCursorStmt::_internal_portalname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.portalname_.Get();
}
inline void DeclareCursorStmt::_internal_set_portalname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.portalname_.Set(value, GetArena());
}
inline std::string* DeclareCursorStmt::_internal_mutable_portalname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.portalname_.Mutable( GetArena());
}
inline std::string* DeclareCursorStmt::release_portalname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DeclareCursorStmt.portalname)
  return _impl_.portalname_.Release();
}
inline void DeclareCursorStmt::set_allocated_portalname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.portalname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.portalname_.IsDefault()) {
          _impl_.portalname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.DeclareCursorStmt.portalname)
}

// int32 options = 2 [json_name = "options"];
inline void DeclareCursorStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_ = 0;
}
inline ::int32_t DeclareCursorStmt::options() const {
  // @@protoc_insertion_point(field_get:pg_query.DeclareCursorStmt.options)
  return _internal_options();
}
inline void DeclareCursorStmt::set_options(::int32_t value) {
  _internal_set_options(value);
  // @@protoc_insertion_point(field_set:pg_query.DeclareCursorStmt.options)
}
inline ::int32_t DeclareCursorStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline void DeclareCursorStmt::_internal_set_options(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.options_ = value;
}

// .pg_query.Node query = 3 [json_name = "query"];
inline bool DeclareCursorStmt::has_query() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.query_ != nullptr);
  return value;
}
inline void DeclareCursorStmt::clear_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.query_ != nullptr) _impl_.query_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& DeclareCursorStmt::_internal_query() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& DeclareCursorStmt::query() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DeclareCursorStmt.query)
  return _internal_query();
}
inline void DeclareCursorStmt::unsafe_arena_set_allocated_query(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.query_);
  }
  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DeclareCursorStmt.query)
}
inline ::pg_query::Node* DeclareCursorStmt::release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.query_;
  _impl_.query_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* DeclareCursorStmt::unsafe_arena_release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DeclareCursorStmt.query)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.query_;
  _impl_.query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* DeclareCursorStmt::_internal_mutable_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.query_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.query_;
}
inline ::pg_query::Node* DeclareCursorStmt::mutable_query() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_query();
  // @@protoc_insertion_point(field_mutable:pg_query.DeclareCursorStmt.query)
  return _msg;
}
inline void DeclareCursorStmt::set_allocated_query(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.query_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.DeclareCursorStmt.query)
}

// -------------------------------------------------------------------

// ClosePortalStmt

// string portalname = 1 [json_name = "portalname"];
inline void ClosePortalStmt::clear_portalname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.portalname_.ClearToEmpty();
}
inline const std::string& ClosePortalStmt::portalname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ClosePortalStmt.portalname)
  return _internal_portalname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ClosePortalStmt::set_portalname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.portalname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ClosePortalStmt.portalname)
}
inline std::string* ClosePortalStmt::mutable_portalname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_portalname();
  // @@protoc_insertion_point(field_mutable:pg_query.ClosePortalStmt.portalname)
  return _s;
}
inline const std::string& ClosePortalStmt::_internal_portalname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.portalname_.Get();
}
inline void ClosePortalStmt::_internal_set_portalname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.portalname_.Set(value, GetArena());
}
inline std::string* ClosePortalStmt::_internal_mutable_portalname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.portalname_.Mutable( GetArena());
}
inline std::string* ClosePortalStmt::release_portalname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ClosePortalStmt.portalname)
  return _impl_.portalname_.Release();
}
inline void ClosePortalStmt::set_allocated_portalname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.portalname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.portalname_.IsDefault()) {
          _impl_.portalname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.ClosePortalStmt.portalname)
}

// -------------------------------------------------------------------

// FetchStmt

// .pg_query.FetchDirection direction = 1 [json_name = "direction"];
inline void FetchStmt::clear_direction() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.direction_ = 0;
}
inline ::pg_query::FetchDirection FetchStmt::direction() const {
  // @@protoc_insertion_point(field_get:pg_query.FetchStmt.direction)
  return _internal_direction();
}
inline void FetchStmt::set_direction(::pg_query::FetchDirection value) {
  _internal_set_direction(value);
  // @@protoc_insertion_point(field_set:pg_query.FetchStmt.direction)
}
inline ::pg_query::FetchDirection FetchStmt::_internal_direction() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::FetchDirection>(_impl_.direction_);
}
inline void FetchStmt::_internal_set_direction(::pg_query::FetchDirection value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.direction_ = value;
}

// int64 how_many = 2 [json_name = "howMany"];
inline void FetchStmt::clear_how_many() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.how_many_ = ::int64_t{0};
}
inline ::int64_t FetchStmt::how_many() const {
  // @@protoc_insertion_point(field_get:pg_query.FetchStmt.how_many)
  return _internal_how_many();
}
inline void FetchStmt::set_how_many(::int64_t value) {
  _internal_set_how_many(value);
  // @@protoc_insertion_point(field_set:pg_query.FetchStmt.how_many)
}
inline ::int64_t FetchStmt::_internal_how_many() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.how_many_;
}
inline void FetchStmt::_internal_set_how_many(::int64_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.how_many_ = value;
}

// string portalname = 3 [json_name = "portalname"];
inline void FetchStmt::clear_portalname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.portalname_.ClearToEmpty();
}
inline const std::string& FetchStmt::portalname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FetchStmt.portalname)
  return _internal_portalname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void FetchStmt::set_portalname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.portalname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.FetchStmt.portalname)
}
inline std::string* FetchStmt::mutable_portalname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_portalname();
  // @@protoc_insertion_point(field_mutable:pg_query.FetchStmt.portalname)
  return _s;
}
inline const std::string& FetchStmt::_internal_portalname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.portalname_.Get();
}
inline void FetchStmt::_internal_set_portalname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.portalname_.Set(value, GetArena());
}
inline std::string* FetchStmt::_internal_mutable_portalname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.portalname_.Mutable( GetArena());
}
inline std::string* FetchStmt::release_portalname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.FetchStmt.portalname)
  return _impl_.portalname_.Release();
}
inline void FetchStmt::set_allocated_portalname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.portalname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.portalname_.IsDefault()) {
          _impl_.portalname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.FetchStmt.portalname)
}

// bool ismove = 4 [json_name = "ismove"];
inline void FetchStmt::clear_ismove() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ismove_ = false;
}
inline bool FetchStmt::ismove() const {
  // @@protoc_insertion_point(field_get:pg_query.FetchStmt.ismove)
  return _internal_ismove();
}
inline void FetchStmt::set_ismove(bool value) {
  _internal_set_ismove(value);
  // @@protoc_insertion_point(field_set:pg_query.FetchStmt.ismove)
}
inline bool FetchStmt::_internal_ismove() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ismove_;
}
inline void FetchStmt::_internal_set_ismove(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ismove_ = value;
}

// -------------------------------------------------------------------

// IndexStmt

// string idxname = 1 [json_name = "idxname"];
inline void IndexStmt::clear_idxname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.idxname_.ClearToEmpty();
}
inline const std::string& IndexStmt::idxname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.idxname)
  return _internal_idxname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void IndexStmt::set_idxname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.idxname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.idxname)
}
inline std::string* IndexStmt::mutable_idxname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_idxname();
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.idxname)
  return _s;
}
inline const std::string& IndexStmt::_internal_idxname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.idxname_.Get();
}
inline void IndexStmt::_internal_set_idxname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.idxname_.Set(value, GetArena());
}
inline std::string* IndexStmt::_internal_mutable_idxname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.idxname_.Mutable( GetArena());
}
inline std::string* IndexStmt::release_idxname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IndexStmt.idxname)
  return _impl_.idxname_.Release();
}
inline void IndexStmt::set_allocated_idxname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.idxname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.idxname_.IsDefault()) {
          _impl_.idxname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexStmt.idxname)
}

// .pg_query.RangeVar relation = 2 [json_name = "relation"];
inline bool IndexStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void IndexStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& IndexStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& IndexStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.relation)
  return _internal_relation();
}
inline void IndexStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IndexStmt.relation)
}
inline ::pg_query::RangeVar* IndexStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* IndexStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IndexStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* IndexStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* IndexStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.relation)
  return _msg;
}
inline void IndexStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexStmt.relation)
}

// string access_method = 3 [json_name = "accessMethod"];
inline void IndexStmt::clear_access_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.access_method_.ClearToEmpty();
}
inline const std::string& IndexStmt::access_method() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.access_method)
  return _internal_access_method();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void IndexStmt::set_access_method(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.access_method_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.access_method)
}
inline std::string* IndexStmt::mutable_access_method() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_access_method();
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.access_method)
  return _s;
}
inline const std::string& IndexStmt::_internal_access_method() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.access_method_.Get();
}
inline void IndexStmt::_internal_set_access_method(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.access_method_.Set(value, GetArena());
}
inline std::string* IndexStmt::_internal_mutable_access_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.access_method_.Mutable( GetArena());
}
inline std::string* IndexStmt::release_access_method() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IndexStmt.access_method)
  return _impl_.access_method_.Release();
}
inline void IndexStmt::set_allocated_access_method(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.access_method_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.access_method_.IsDefault()) {
          _impl_.access_method_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexStmt.access_method)
}

// string table_space = 4 [json_name = "tableSpace"];
inline void IndexStmt::clear_table_space() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.table_space_.ClearToEmpty();
}
inline const std::string& IndexStmt::table_space() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.table_space)
  return _internal_table_space();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void IndexStmt::set_table_space(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.table_space_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.table_space)
}
inline std::string* IndexStmt::mutable_table_space() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_table_space();
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.table_space)
  return _s;
}
inline const std::string& IndexStmt::_internal_table_space() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.table_space_.Get();
}
inline void IndexStmt::_internal_set_table_space(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.table_space_.Set(value, GetArena());
}
inline std::string* IndexStmt::_internal_mutable_table_space() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.table_space_.Mutable( GetArena());
}
inline std::string* IndexStmt::release_table_space() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IndexStmt.table_space)
  return _impl_.table_space_.Release();
}
inline void IndexStmt::set_allocated_table_space(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.table_space_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.table_space_.IsDefault()) {
          _impl_.table_space_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_index_params().size();
}
inline int IndexStmt::index_params_size() const {
  return _internal_index_params_size();
}
inline void IndexStmt::clear_index_params() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.index_params_.Clear();
}
inline ::pg_query::Node* IndexStmt::mutable_index_params(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.index_params)
  return _internal_mutable_index_params()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* IndexStmt::mutable_index_params()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexStmt.index_params)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_index_params();
}
inline const ::pg_query::Node& IndexStmt::index_params(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.index_params)
  return _internal_index_params().Get(index);
}
inline ::pg_query::Node* IndexStmt::add_index_params() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_index_params()->Add();
  // @@protoc_insertion_point(field_add:pg_query.IndexStmt.index_params)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& IndexStmt::index_params() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.IndexStmt.index_params)
  return _internal_index_params();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
IndexStmt::_internal_index_params() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.index_params_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
IndexStmt::_internal_mutable_index_params() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.index_params_;
}

// repeated .pg_query.Node index_including_params = 6 [json_name = "indexIncludingParams"];
inline int IndexStmt::_internal_index_including_params_size() const {
  return _internal_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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.index_including_params_.Clear();
}
inline ::pg_query::Node* IndexStmt::mutable_index_including_params(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.index_including_params)
  return _internal_mutable_index_including_params()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* IndexStmt::mutable_index_including_params()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexStmt.index_including_params)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_index_including_params();
}
inline const ::pg_query::Node& IndexStmt::index_including_params(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.index_including_params)
  return _internal_index_including_params().Get(index);
}
inline ::pg_query::Node* IndexStmt::add_index_including_params() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_index_including_params()->Add();
  // @@protoc_insertion_point(field_add:pg_query.IndexStmt.index_including_params)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& IndexStmt::index_including_params() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.IndexStmt.index_including_params)
  return _internal_index_including_params();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
IndexStmt::_internal_index_including_params() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.index_including_params_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
IndexStmt::_internal_mutable_index_including_params() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.index_including_params_;
}

// repeated .pg_query.Node options = 7 [json_name = "options"];
inline int IndexStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int IndexStmt::options_size() const {
  return _internal_options_size();
}
inline void IndexStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* IndexStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* IndexStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& IndexStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* IndexStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.IndexStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& IndexStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.IndexStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
IndexStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
IndexStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// .pg_query.Node where_clause = 8 [json_name = "whereClause"];
inline bool IndexStmt::has_where_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.where_clause_ != nullptr);
  return value;
}
inline void IndexStmt::clear_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.where_clause_ != nullptr) _impl_.where_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& IndexStmt::_internal_where_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.where_clause_);
  }
  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IndexStmt.where_clause)
}
inline ::pg_query::Node* IndexStmt::release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* IndexStmt::unsafe_arena_release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IndexStmt.where_clause)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* IndexStmt::_internal_mutable_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.where_clause_;
}
inline ::pg_query::Node* IndexStmt::mutable_where_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_where_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.where_clause)
  return _msg;
}
inline void IndexStmt::set_allocated_where_clause(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.where_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.exclude_op_names_.Clear();
}
inline ::pg_query::Node* IndexStmt::mutable_exclude_op_names(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.exclude_op_names)
  return _internal_mutable_exclude_op_names()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* IndexStmt::mutable_exclude_op_names()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.IndexStmt.exclude_op_names)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_exclude_op_names();
}
inline const ::pg_query::Node& IndexStmt::exclude_op_names(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.exclude_op_names)
  return _internal_exclude_op_names().Get(index);
}
inline ::pg_query::Node* IndexStmt::add_exclude_op_names() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_exclude_op_names()->Add();
  // @@protoc_insertion_point(field_add:pg_query.IndexStmt.exclude_op_names)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& IndexStmt::exclude_op_names() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.IndexStmt.exclude_op_names)
  return _internal_exclude_op_names();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
IndexStmt::_internal_exclude_op_names() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.exclude_op_names_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
IndexStmt::_internal_mutable_exclude_op_names() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.exclude_op_names_;
}

// string idxcomment = 10 [json_name = "idxcomment"];
inline void IndexStmt::clear_idxcomment() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.idxcomment_.ClearToEmpty();
}
inline const std::string& IndexStmt::idxcomment() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.idxcomment)
  return _internal_idxcomment();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void IndexStmt::set_idxcomment(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.idxcomment_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.idxcomment)
}
inline std::string* IndexStmt::mutable_idxcomment() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_idxcomment();
  // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.idxcomment)
  return _s;
}
inline const std::string& IndexStmt::_internal_idxcomment() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.idxcomment_.Get();
}
inline void IndexStmt::_internal_set_idxcomment(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.idxcomment_.Set(value, GetArena());
}
inline std::string* IndexStmt::_internal_mutable_idxcomment() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.idxcomment_.Mutable( GetArena());
}
inline std::string* IndexStmt::release_idxcomment() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.IndexStmt.idxcomment)
  return _impl_.idxcomment_.Release();
}
inline void IndexStmt::set_allocated_idxcomment(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.idxcomment_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.idxcomment_.IsDefault()) {
          _impl_.idxcomment_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.IndexStmt.idxcomment)
}

// uint32 index_oid = 11 [json_name = "indexOid"];
inline void IndexStmt::clear_index_oid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.index_oid_ = 0u;
}
inline ::uint32_t IndexStmt::index_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.index_oid)
  return _internal_index_oid();
}
inline void IndexStmt::set_index_oid(::uint32_t value) {
  _internal_set_index_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.index_oid)
}
inline ::uint32_t IndexStmt::_internal_index_oid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.index_oid_;
}
inline void IndexStmt::_internal_set_index_oid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.index_oid_ = value;
}

// uint32 old_number = 12 [json_name = "oldNumber"];
inline void IndexStmt::clear_old_number() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.old_number_ = 0u;
}
inline ::uint32_t IndexStmt::old_number() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.old_number)
  return _internal_old_number();
}
inline void IndexStmt::set_old_number(::uint32_t value) {
  _internal_set_old_number(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.old_number)
}
inline ::uint32_t IndexStmt::_internal_old_number() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.old_number_;
}
inline void IndexStmt::_internal_set_old_number(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.old_number_ = value;
}

// uint32 old_create_subid = 13 [json_name = "oldCreateSubid"];
inline void IndexStmt::clear_old_create_subid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.old_create_subid_ = 0u;
}
inline ::uint32_t IndexStmt::old_create_subid() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.old_create_subid)
  return _internal_old_create_subid();
}
inline void IndexStmt::set_old_create_subid(::uint32_t value) {
  _internal_set_old_create_subid(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.old_create_subid)
}
inline ::uint32_t IndexStmt::_internal_old_create_subid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.old_create_subid_;
}
inline void IndexStmt::_internal_set_old_create_subid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.old_create_subid_ = value;
}

// uint32 old_first_relfilelocator_subid = 14 [json_name = "oldFirstRelfilelocatorSubid"];
inline void IndexStmt::clear_old_first_relfilelocator_subid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.old_first_relfilelocator_subid_ = 0u;
}
inline ::uint32_t IndexStmt::old_first_relfilelocator_subid() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.old_first_relfilelocator_subid)
  return _internal_old_first_relfilelocator_subid();
}
inline void IndexStmt::set_old_first_relfilelocator_subid(::uint32_t value) {
  _internal_set_old_first_relfilelocator_subid(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.old_first_relfilelocator_subid)
}
inline ::uint32_t IndexStmt::_internal_old_first_relfilelocator_subid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.old_first_relfilelocator_subid_;
}
inline void IndexStmt::_internal_set_old_first_relfilelocator_subid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.old_first_relfilelocator_subid_ = value;
}

// bool unique = 15 [json_name = "unique"];
inline void IndexStmt::clear_unique() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.unique_ = false;
}
inline bool IndexStmt::unique() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.unique)
  return _internal_unique();
}
inline void IndexStmt::set_unique(bool value) {
  _internal_set_unique(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.unique)
}
inline bool IndexStmt::_internal_unique() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.unique_;
}
inline void IndexStmt::_internal_set_unique(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.unique_ = value;
}

// bool nulls_not_distinct = 16 [json_name = "nulls_not_distinct"];
inline void IndexStmt::clear_nulls_not_distinct() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.nulls_not_distinct_ = false;
}
inline bool IndexStmt::nulls_not_distinct() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.nulls_not_distinct)
  return _internal_nulls_not_distinct();
}
inline void IndexStmt::set_nulls_not_distinct(bool value) {
  _internal_set_nulls_not_distinct(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.nulls_not_distinct)
}
inline bool IndexStmt::_internal_nulls_not_distinct() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.nulls_not_distinct_;
}
inline void IndexStmt::_internal_set_nulls_not_distinct(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.nulls_not_distinct_ = value;
}

// bool primary = 17 [json_name = "primary"];
inline void IndexStmt::clear_primary() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.primary_ = false;
}
inline bool IndexStmt::primary() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.primary)
  return _internal_primary();
}
inline void IndexStmt::set_primary(bool value) {
  _internal_set_primary(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.primary)
}
inline bool IndexStmt::_internal_primary() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.primary_;
}
inline void IndexStmt::_internal_set_primary(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.primary_ = value;
}

// bool isconstraint = 18 [json_name = "isconstraint"];
inline void IndexStmt::clear_isconstraint() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.isconstraint_ = false;
}
inline bool IndexStmt::isconstraint() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.isconstraint)
  return _internal_isconstraint();
}
inline void IndexStmt::set_isconstraint(bool value) {
  _internal_set_isconstraint(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.isconstraint)
}
inline bool IndexStmt::_internal_isconstraint() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.isconstraint_;
}
inline void IndexStmt::_internal_set_isconstraint(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.isconstraint_ = value;
}

// bool deferrable = 19 [json_name = "deferrable"];
inline void IndexStmt::clear_deferrable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.deferrable_ = false;
}
inline bool IndexStmt::deferrable() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.deferrable)
  return _internal_deferrable();
}
inline void IndexStmt::set_deferrable(bool value) {
  _internal_set_deferrable(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.deferrable)
}
inline bool IndexStmt::_internal_deferrable() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.deferrable_;
}
inline void IndexStmt::_internal_set_deferrable(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.deferrable_ = value;
}

// bool initdeferred = 20 [json_name = "initdeferred"];
inline void IndexStmt::clear_initdeferred() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.initdeferred_ = false;
}
inline bool IndexStmt::initdeferred() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.initdeferred)
  return _internal_initdeferred();
}
inline void IndexStmt::set_initdeferred(bool value) {
  _internal_set_initdeferred(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.initdeferred)
}
inline bool IndexStmt::_internal_initdeferred() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.initdeferred_;
}
inline void IndexStmt::_internal_set_initdeferred(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.initdeferred_ = value;
}

// bool transformed = 21 [json_name = "transformed"];
inline void IndexStmt::clear_transformed() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.transformed_ = false;
}
inline bool IndexStmt::transformed() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.transformed)
  return _internal_transformed();
}
inline void IndexStmt::set_transformed(bool value) {
  _internal_set_transformed(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.transformed)
}
inline bool IndexStmt::_internal_transformed() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.transformed_;
}
inline void IndexStmt::_internal_set_transformed(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.transformed_ = value;
}

// bool concurrent = 22 [json_name = "concurrent"];
inline void IndexStmt::clear_concurrent() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.concurrent_ = false;
}
inline bool IndexStmt::concurrent() const {
  // @@protoc_insertion_point(field_get:pg_query.IndexStmt.concurrent)
  return _internal_concurrent();
}
inline void IndexStmt::set_concurrent(bool value) {
  _internal_set_concurrent(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.concurrent)
}
inline bool IndexStmt::_internal_concurrent() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.concurrent_;
}
inline void IndexStmt::_internal_set_concurrent(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.concurrent_ = value;
}

// bool if_not_exists = 23 [json_name = "if_not_exists"];
inline void IndexStmt::clear_if_not_exists() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.if_not_exists_ = false;
}
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::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.if_not_exists)
}
inline bool IndexStmt::_internal_if_not_exists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.if_not_exists_;
}
inline void IndexStmt::_internal_set_if_not_exists(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.if_not_exists_ = value;
}

// bool reset_default_tblspc = 24 [json_name = "reset_default_tblspc"];
inline void IndexStmt::clear_reset_default_tblspc() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.reset_default_tblspc_ = false;
}
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::set_reset_default_tblspc(bool value) {
  _internal_set_reset_default_tblspc(value);
  // @@protoc_insertion_point(field_set:pg_query.IndexStmt.reset_default_tblspc)
}
inline bool IndexStmt::_internal_reset_default_tblspc() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.reset_default_tblspc_;
}
inline void IndexStmt::_internal_set_reset_default_tblspc(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.reset_default_tblspc_ = value;
}

// -------------------------------------------------------------------

// CreateStatsStmt

// repeated .pg_query.Node defnames = 1 [json_name = "defnames"];
inline int CreateStatsStmt::_internal_defnames_size() const {
  return _internal_defnames().size();
}
inline int CreateStatsStmt::defnames_size() const {
  return _internal_defnames_size();
}
inline void CreateStatsStmt::clear_defnames() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.defnames_.Clear();
}
inline ::pg_query::Node* CreateStatsStmt::mutable_defnames(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.defnames)
  return _internal_mutable_defnames()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateStatsStmt::mutable_defnames()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStatsStmt.defnames)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_defnames();
}
inline const ::pg_query::Node& CreateStatsStmt::defnames(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.defnames)
  return _internal_defnames().Get(index);
}
inline ::pg_query::Node* CreateStatsStmt::add_defnames() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_defnames()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateStatsStmt.defnames)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateStatsStmt::defnames() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateStatsStmt.defnames)
  return _internal_defnames();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateStatsStmt::_internal_defnames() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.defnames_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateStatsStmt::_internal_mutable_defnames() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.defnames_;
}

// repeated .pg_query.Node stat_types = 2 [json_name = "stat_types"];
inline int CreateStatsStmt::_internal_stat_types_size() const {
  return _internal_stat_types().size();
}
inline int CreateStatsStmt::stat_types_size() const {
  return _internal_stat_types_size();
}
inline void CreateStatsStmt::clear_stat_types() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stat_types_.Clear();
}
inline ::pg_query::Node* CreateStatsStmt::mutable_stat_types(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.stat_types)
  return _internal_mutable_stat_types()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateStatsStmt::mutable_stat_types()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStatsStmt.stat_types)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_stat_types();
}
inline const ::pg_query::Node& CreateStatsStmt::stat_types(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.stat_types)
  return _internal_stat_types().Get(index);
}
inline ::pg_query::Node* CreateStatsStmt::add_stat_types() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_stat_types()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateStatsStmt.stat_types)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateStatsStmt::stat_types() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateStatsStmt.stat_types)
  return _internal_stat_types();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateStatsStmt::_internal_stat_types() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.stat_types_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateStatsStmt::_internal_mutable_stat_types() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.stat_types_;
}

// repeated .pg_query.Node exprs = 3 [json_name = "exprs"];
inline int CreateStatsStmt::_internal_exprs_size() const {
  return _internal_exprs().size();
}
inline int CreateStatsStmt::exprs_size() const {
  return _internal_exprs_size();
}
inline void CreateStatsStmt::clear_exprs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.exprs_.Clear();
}
inline ::pg_query::Node* CreateStatsStmt::mutable_exprs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.exprs)
  return _internal_mutable_exprs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateStatsStmt::mutable_exprs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStatsStmt.exprs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_exprs();
}
inline const ::pg_query::Node& CreateStatsStmt::exprs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.exprs)
  return _internal_exprs().Get(index);
}
inline ::pg_query::Node* CreateStatsStmt::add_exprs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_exprs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateStatsStmt.exprs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateStatsStmt::exprs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateStatsStmt.exprs)
  return _internal_exprs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateStatsStmt::_internal_exprs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.exprs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateStatsStmt::_internal_mutable_exprs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.exprs_;
}

// repeated .pg_query.Node relations = 4 [json_name = "relations"];
inline int CreateStatsStmt::_internal_relations_size() const {
  return _internal_relations().size();
}
inline int CreateStatsStmt::relations_size() const {
  return _internal_relations_size();
}
inline void CreateStatsStmt::clear_relations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relations_.Clear();
}
inline ::pg_query::Node* CreateStatsStmt::mutable_relations(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.relations)
  return _internal_mutable_relations()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateStatsStmt::mutable_relations()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStatsStmt.relations)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_relations();
}
inline const ::pg_query::Node& CreateStatsStmt::relations(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.relations)
  return _internal_relations().Get(index);
}
inline ::pg_query::Node* CreateStatsStmt::add_relations() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_relations()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateStatsStmt.relations)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateStatsStmt::relations() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateStatsStmt.relations)
  return _internal_relations();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateStatsStmt::_internal_relations() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.relations_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateStatsStmt::_internal_mutable_relations() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.relations_;
}

// string stxcomment = 5 [json_name = "stxcomment"];
inline void CreateStatsStmt::clear_stxcomment() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stxcomment_.ClearToEmpty();
}
inline const std::string& CreateStatsStmt::stxcomment() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.stxcomment)
  return _internal_stxcomment();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateStatsStmt::set_stxcomment(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.stxcomment_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateStatsStmt.stxcomment)
}
inline std::string* CreateStatsStmt::mutable_stxcomment() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_stxcomment();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.stxcomment)
  return _s;
}
inline const std::string& CreateStatsStmt::_internal_stxcomment() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.stxcomment_.Get();
}
inline void CreateStatsStmt::_internal_set_stxcomment(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.stxcomment_.Set(value, GetArena());
}
inline std::string* CreateStatsStmt::_internal_mutable_stxcomment() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.stxcomment_.Mutable( GetArena());
}
inline std::string* CreateStatsStmt::release_stxcomment() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateStatsStmt.stxcomment)
  return _impl_.stxcomment_.Release();
}
inline void CreateStatsStmt::set_allocated_stxcomment(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stxcomment_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.stxcomment_.IsDefault()) {
          _impl_.stxcomment_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStatsStmt.stxcomment)
}

// bool transformed = 6 [json_name = "transformed"];
inline void CreateStatsStmt::clear_transformed() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.transformed_ = false;
}
inline bool CreateStatsStmt::transformed() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.transformed)
  return _internal_transformed();
}
inline void CreateStatsStmt::set_transformed(bool value) {
  _internal_set_transformed(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateStatsStmt.transformed)
}
inline bool CreateStatsStmt::_internal_transformed() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.transformed_;
}
inline void CreateStatsStmt::_internal_set_transformed(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.transformed_ = value;
}

// bool if_not_exists = 7 [json_name = "if_not_exists"];
inline void CreateStatsStmt::clear_if_not_exists() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.if_not_exists_ = false;
}
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::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateStatsStmt.if_not_exists)
}
inline bool CreateStatsStmt::_internal_if_not_exists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.if_not_exists_;
}
inline void CreateStatsStmt::_internal_set_if_not_exists(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.if_not_exists_ = value;
}

// -------------------------------------------------------------------

// StatsElem

// string name = 1 [json_name = "name"];
inline void StatsElem::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& StatsElem::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.StatsElem.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void StatsElem::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.StatsElem.name)
}
inline std::string* StatsElem::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.StatsElem.name)
  return _s;
}
inline const std::string& StatsElem::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void StatsElem::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* StatsElem::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* StatsElem::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.StatsElem.name)
  return _impl_.name_.Release();
}
inline void StatsElem::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.StatsElem.name)
}

// .pg_query.Node expr = 2 [json_name = "expr"];
inline bool StatsElem::has_expr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.expr_ != nullptr);
  return value;
}
inline void StatsElem::clear_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.expr_ != nullptr) _impl_.expr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& StatsElem::_internal_expr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.expr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& StatsElem::expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.StatsElem.expr)
  return _internal_expr();
}
inline void StatsElem::unsafe_arena_set_allocated_expr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.expr_);
  }
  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.StatsElem.expr)
}
inline ::pg_query::Node* StatsElem::release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.expr_;
  _impl_.expr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* StatsElem::unsafe_arena_release_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.StatsElem.expr)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.expr_;
  _impl_.expr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* StatsElem::_internal_mutable_expr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.expr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.expr_;
}
inline ::pg_query::Node* StatsElem::mutable_expr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_expr();
  // @@protoc_insertion_point(field_mutable:pg_query.StatsElem.expr)
  return _msg;
}
inline void StatsElem::set_allocated_expr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.expr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.expr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.StatsElem.expr)
}

// -------------------------------------------------------------------

// AlterStatsStmt

// repeated .pg_query.Node defnames = 1 [json_name = "defnames"];
inline int AlterStatsStmt::_internal_defnames_size() const {
  return _internal_defnames().size();
}
inline int AlterStatsStmt::defnames_size() const {
  return _internal_defnames_size();
}
inline void AlterStatsStmt::clear_defnames() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.defnames_.Clear();
}
inline ::pg_query::Node* AlterStatsStmt::mutable_defnames(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterStatsStmt.defnames)
  return _internal_mutable_defnames()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterStatsStmt::mutable_defnames()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterStatsStmt.defnames)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_defnames();
}
inline const ::pg_query::Node& AlterStatsStmt::defnames(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterStatsStmt.defnames)
  return _internal_defnames().Get(index);
}
inline ::pg_query::Node* AlterStatsStmt::add_defnames() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_defnames()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterStatsStmt.defnames)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterStatsStmt::defnames() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterStatsStmt.defnames)
  return _internal_defnames();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterStatsStmt::_internal_defnames() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.defnames_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterStatsStmt::_internal_mutable_defnames() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.defnames_;
}

// int32 stxstattarget = 2 [json_name = "stxstattarget"];
inline void AlterStatsStmt::clear_stxstattarget() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stxstattarget_ = 0;
}
inline ::int32_t AlterStatsStmt::stxstattarget() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterStatsStmt.stxstattarget)
  return _internal_stxstattarget();
}
inline void AlterStatsStmt::set_stxstattarget(::int32_t value) {
  _internal_set_stxstattarget(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterStatsStmt.stxstattarget)
}
inline ::int32_t AlterStatsStmt::_internal_stxstattarget() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.stxstattarget_;
}
inline void AlterStatsStmt::_internal_set_stxstattarget(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.stxstattarget_ = value;
}

// bool missing_ok = 3 [json_name = "missing_ok"];
inline void AlterStatsStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool AlterStatsStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterStatsStmt.missing_ok)
  return _internal_missing_ok();
}
inline void AlterStatsStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterStatsStmt.missing_ok)
}
inline bool AlterStatsStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void AlterStatsStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// -------------------------------------------------------------------

// CreateFunctionStmt

// bool is_procedure = 1 [json_name = "is_procedure"];
inline void CreateFunctionStmt::clear_is_procedure() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_procedure_ = false;
}
inline bool CreateFunctionStmt::is_procedure() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.is_procedure)
  return _internal_is_procedure();
}
inline void CreateFunctionStmt::set_is_procedure(bool value) {
  _internal_set_is_procedure(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateFunctionStmt.is_procedure)
}
inline bool CreateFunctionStmt::_internal_is_procedure() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_procedure_;
}
inline void CreateFunctionStmt::_internal_set_is_procedure(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_procedure_ = value;
}

// bool replace = 2 [json_name = "replace"];
inline void CreateFunctionStmt::clear_replace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.replace_ = false;
}
inline bool CreateFunctionStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.replace)
  return _internal_replace();
}
inline void CreateFunctionStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateFunctionStmt.replace)
}
inline bool CreateFunctionStmt::_internal_replace() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.replace_;
}
inline void CreateFunctionStmt::_internal_set_replace(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.replace_ = value;
}

// repeated .pg_query.Node funcname = 3 [json_name = "funcname"];
inline int CreateFunctionStmt::_internal_funcname_size() const {
  return _internal_funcname().size();
}
inline int CreateFunctionStmt::funcname_size() const {
  return _internal_funcname_size();
}
inline void CreateFunctionStmt::clear_funcname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.funcname_.Clear();
}
inline ::pg_query::Node* CreateFunctionStmt::mutable_funcname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFunctionStmt.funcname)
  return _internal_mutable_funcname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateFunctionStmt::mutable_funcname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFunctionStmt.funcname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_funcname();
}
inline const ::pg_query::Node& CreateFunctionStmt::funcname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.funcname)
  return _internal_funcname().Get(index);
}
inline ::pg_query::Node* CreateFunctionStmt::add_funcname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_funcname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateFunctionStmt.funcname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateFunctionStmt::funcname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateFunctionStmt.funcname)
  return _internal_funcname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateFunctionStmt::_internal_funcname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.funcname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateFunctionStmt::_internal_mutable_funcname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.funcname_;
}

// repeated .pg_query.Node parameters = 4 [json_name = "parameters"];
inline int CreateFunctionStmt::_internal_parameters_size() const {
  return _internal_parameters().size();
}
inline int CreateFunctionStmt::parameters_size() const {
  return _internal_parameters_size();
}
inline void CreateFunctionStmt::clear_parameters() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.parameters_.Clear();
}
inline ::pg_query::Node* CreateFunctionStmt::mutable_parameters(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFunctionStmt.parameters)
  return _internal_mutable_parameters()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateFunctionStmt::mutable_parameters()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFunctionStmt.parameters)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_parameters();
}
inline const ::pg_query::Node& CreateFunctionStmt::parameters(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.parameters)
  return _internal_parameters().Get(index);
}
inline ::pg_query::Node* CreateFunctionStmt::add_parameters() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_parameters()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateFunctionStmt.parameters)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateFunctionStmt::parameters() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateFunctionStmt.parameters)
  return _internal_parameters();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateFunctionStmt::_internal_parameters() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.parameters_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateFunctionStmt::_internal_mutable_parameters() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.parameters_;
}

// .pg_query.TypeName return_type = 5 [json_name = "returnType"];
inline bool CreateFunctionStmt::has_return_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.return_type_ != nullptr);
  return value;
}
inline void CreateFunctionStmt::clear_return_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.return_type_ != nullptr) _impl_.return_type_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::TypeName& CreateFunctionStmt::_internal_return_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.return_type_);
  }
  _impl_.return_type_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateFunctionStmt.return_type)
}
inline ::pg_query::TypeName* CreateFunctionStmt::release_return_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* released = _impl_.return_type_;
  _impl_.return_type_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* CreateFunctionStmt::unsafe_arena_release_return_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateFunctionStmt.return_type)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* temp = _impl_.return_type_;
  _impl_.return_type_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateFunctionStmt::_internal_mutable_return_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.return_type_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.return_type_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.return_type_;
}
inline ::pg_query::TypeName* CreateFunctionStmt::mutable_return_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_return_type();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFunctionStmt.return_type)
  return _msg;
}
inline void CreateFunctionStmt::set_allocated_return_type(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.return_type_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.return_type_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@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 _internal_options().size();
}
inline int CreateFunctionStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateFunctionStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreateFunctionStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFunctionStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateFunctionStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFunctionStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreateFunctionStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreateFunctionStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateFunctionStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateFunctionStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateFunctionStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateFunctionStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateFunctionStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// .pg_query.Node sql_body = 7 [json_name = "sql_body"];
inline bool CreateFunctionStmt::has_sql_body() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sql_body_ != nullptr);
  return value;
}
inline void CreateFunctionStmt::clear_sql_body() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.sql_body_ != nullptr) _impl_.sql_body_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& CreateFunctionStmt::_internal_sql_body() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.sql_body_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CreateFunctionStmt::sql_body() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.sql_body)
  return _internal_sql_body();
}
inline void CreateFunctionStmt::unsafe_arena_set_allocated_sql_body(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sql_body_);
  }
  _impl_.sql_body_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateFunctionStmt.sql_body)
}
inline ::pg_query::Node* CreateFunctionStmt::release_sql_body() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.sql_body_;
  _impl_.sql_body_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CreateFunctionStmt::unsafe_arena_release_sql_body() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateFunctionStmt.sql_body)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.sql_body_;
  _impl_.sql_body_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CreateFunctionStmt::_internal_mutable_sql_body() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.sql_body_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.sql_body_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.sql_body_;
}
inline ::pg_query::Node* CreateFunctionStmt::mutable_sql_body() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_sql_body();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateFunctionStmt.sql_body)
  return _msg;
}
inline void CreateFunctionStmt::set_allocated_sql_body(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.sql_body_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.sql_body_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateFunctionStmt.sql_body)
}

// -------------------------------------------------------------------

// FunctionParameter

// string name = 1 [json_name = "name"];
inline void FunctionParameter::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& FunctionParameter::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FunctionParameter.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void FunctionParameter::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.FunctionParameter.name)
}
inline std::string* FunctionParameter::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.FunctionParameter.name)
  return _s;
}
inline const std::string& FunctionParameter::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void FunctionParameter::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* FunctionParameter::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* FunctionParameter::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.FunctionParameter.name)
  return _impl_.name_.Release();
}
inline void FunctionParameter::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.FunctionParameter.name)
}

// .pg_query.TypeName arg_type = 2 [json_name = "argType"];
inline bool FunctionParameter::has_arg_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arg_type_ != nullptr);
  return value;
}
inline void FunctionParameter::clear_arg_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.arg_type_ != nullptr) _impl_.arg_type_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::TypeName& FunctionParameter::_internal_arg_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.arg_type_);
  }
  _impl_.arg_type_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FunctionParameter.arg_type)
}
inline ::pg_query::TypeName* FunctionParameter::release_arg_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* released = _impl_.arg_type_;
  _impl_.arg_type_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* FunctionParameter::unsafe_arena_release_arg_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.FunctionParameter.arg_type)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* temp = _impl_.arg_type_;
  _impl_.arg_type_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* FunctionParameter::_internal_mutable_arg_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.arg_type_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.arg_type_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.arg_type_;
}
inline ::pg_query::TypeName* FunctionParameter::mutable_arg_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_arg_type();
  // @@protoc_insertion_point(field_mutable:pg_query.FunctionParameter.arg_type)
  return _msg;
}
inline void FunctionParameter::set_allocated_arg_type(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.arg_type_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.arg_type_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.FunctionParameter.arg_type)
}

// .pg_query.FunctionParameterMode mode = 3 [json_name = "mode"];
inline void FunctionParameter::clear_mode() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.mode_ = 0;
}
inline ::pg_query::FunctionParameterMode FunctionParameter::mode() const {
  // @@protoc_insertion_point(field_get:pg_query.FunctionParameter.mode)
  return _internal_mode();
}
inline void FunctionParameter::set_mode(::pg_query::FunctionParameterMode value) {
  _internal_set_mode(value);
  // @@protoc_insertion_point(field_set:pg_query.FunctionParameter.mode)
}
inline ::pg_query::FunctionParameterMode FunctionParameter::_internal_mode() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::FunctionParameterMode>(_impl_.mode_);
}
inline void FunctionParameter::_internal_set_mode(::pg_query::FunctionParameterMode value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.mode_ = value;
}

// .pg_query.Node defexpr = 4 [json_name = "defexpr"];
inline bool FunctionParameter::has_defexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.defexpr_ != nullptr);
  return value;
}
inline void FunctionParameter::clear_defexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.defexpr_ != nullptr) _impl_.defexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& FunctionParameter::_internal_defexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.defexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& FunctionParameter::defexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.FunctionParameter.defexpr)
  return _internal_defexpr();
}
inline void FunctionParameter::unsafe_arena_set_allocated_defexpr(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.defexpr_);
  }
  _impl_.defexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FunctionParameter.defexpr)
}
inline ::pg_query::Node* FunctionParameter::release_defexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.defexpr_;
  _impl_.defexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* FunctionParameter::unsafe_arena_release_defexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.FunctionParameter.defexpr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.defexpr_;
  _impl_.defexpr_ = nullptr;
  return temp;
}
inline ::pg_query::Node* FunctionParameter::_internal_mutable_defexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.defexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.defexpr_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.defexpr_;
}
inline ::pg_query::Node* FunctionParameter::mutable_defexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_defexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.FunctionParameter.defexpr)
  return _msg;
}
inline void FunctionParameter::set_allocated_defexpr(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.defexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.defexpr_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.FunctionParameter.defexpr)
}

// -------------------------------------------------------------------

// AlterFunctionStmt

// .pg_query.ObjectType objtype = 1 [json_name = "objtype"];
inline void AlterFunctionStmt::clear_objtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objtype_ = 0;
}
inline ::pg_query::ObjectType AlterFunctionStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterFunctionStmt.objtype)
  return _internal_objtype();
}
inline void AlterFunctionStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterFunctionStmt.objtype)
}
inline ::pg_query::ObjectType AlterFunctionStmt::_internal_objtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.objtype_);
}
inline void AlterFunctionStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.objtype_ = value;
}

// .pg_query.ObjectWithArgs func = 2 [json_name = "func"];
inline bool AlterFunctionStmt::has_func() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.func_ != nullptr);
  return value;
}
inline void AlterFunctionStmt::clear_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.func_ != nullptr) _impl_.func_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::ObjectWithArgs& AlterFunctionStmt::_internal_func() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::ObjectWithArgs* p = _impl_.func_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::ObjectWithArgs&>(::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& AlterFunctionStmt::func() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterFunctionStmt.func)
  return _internal_func();
}
inline void AlterFunctionStmt::unsafe_arena_set_allocated_func(::pg_query::ObjectWithArgs* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.func_);
  }
  _impl_.func_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterFunctionStmt.func)
}
inline ::pg_query::ObjectWithArgs* AlterFunctionStmt::release_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::ObjectWithArgs* released = _impl_.func_;
  _impl_.func_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::ObjectWithArgs* AlterFunctionStmt::unsafe_arena_release_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterFunctionStmt.func)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::ObjectWithArgs* temp = _impl_.func_;
  _impl_.func_ = nullptr;
  return temp;
}
inline ::pg_query::ObjectWithArgs* AlterFunctionStmt::_internal_mutable_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.func_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
    _impl_.func_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(p);
  }
  return _impl_.func_;
}
inline ::pg_query::ObjectWithArgs* AlterFunctionStmt::mutable_func() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ObjectWithArgs* _msg = _internal_mutable_func();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterFunctionStmt.func)
  return _msg;
}
inline void AlterFunctionStmt::set_allocated_func(::pg_query::ObjectWithArgs* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::ObjectWithArgs*>(_impl_.func_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::ObjectWithArgs*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.func_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(value);
  // @@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 _internal_actions().size();
}
inline int AlterFunctionStmt::actions_size() const {
  return _internal_actions_size();
}
inline void AlterFunctionStmt::clear_actions() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.actions_.Clear();
}
inline ::pg_query::Node* AlterFunctionStmt::mutable_actions(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterFunctionStmt.actions)
  return _internal_mutable_actions()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterFunctionStmt::mutable_actions()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterFunctionStmt.actions)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_actions();
}
inline const ::pg_query::Node& AlterFunctionStmt::actions(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterFunctionStmt.actions)
  return _internal_actions().Get(index);
}
inline ::pg_query::Node* AlterFunctionStmt::add_actions() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_actions()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterFunctionStmt.actions)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterFunctionStmt::actions() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterFunctionStmt.actions)
  return _internal_actions();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterFunctionStmt::_internal_actions() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.actions_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterFunctionStmt::_internal_mutable_actions() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.actions_;
}

// -------------------------------------------------------------------

// DoStmt

// repeated .pg_query.Node args = 1 [json_name = "args"];
inline int DoStmt::_internal_args_size() const {
  return _internal_args().size();
}
inline int DoStmt::args_size() const {
  return _internal_args_size();
}
inline void DoStmt::clear_args() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.args_.Clear();
}
inline ::pg_query::Node* DoStmt::mutable_args(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.DoStmt.args)
  return _internal_mutable_args()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* DoStmt::mutable_args()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DoStmt.args)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_args();
}
inline const ::pg_query::Node& DoStmt::args(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DoStmt.args)
  return _internal_args().Get(index);
}
inline ::pg_query::Node* DoStmt::add_args() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_args()->Add();
  // @@protoc_insertion_point(field_add:pg_query.DoStmt.args)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& DoStmt::args() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.DoStmt.args)
  return _internal_args();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
DoStmt::_internal_args() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.args_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
DoStmt::_internal_mutable_args() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.args_;
}

// -------------------------------------------------------------------

// InlineCodeBlock

// string source_text = 1 [json_name = "source_text"];
inline void InlineCodeBlock::clear_source_text() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.source_text_.ClearToEmpty();
}
inline const std::string& InlineCodeBlock::source_text() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.InlineCodeBlock.source_text)
  return _internal_source_text();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void InlineCodeBlock::set_source_text(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.source_text_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.InlineCodeBlock.source_text)
}
inline std::string* InlineCodeBlock::mutable_source_text() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_source_text();
  // @@protoc_insertion_point(field_mutable:pg_query.InlineCodeBlock.source_text)
  return _s;
}
inline const std::string& InlineCodeBlock::_internal_source_text() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.source_text_.Get();
}
inline void InlineCodeBlock::_internal_set_source_text(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.source_text_.Set(value, GetArena());
}
inline std::string* InlineCodeBlock::_internal_mutable_source_text() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.source_text_.Mutable( GetArena());
}
inline std::string* InlineCodeBlock::release_source_text() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.InlineCodeBlock.source_text)
  return _impl_.source_text_.Release();
}
inline void InlineCodeBlock::set_allocated_source_text(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.source_text_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.source_text_.IsDefault()) {
          _impl_.source_text_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.InlineCodeBlock.source_text)
}

// uint32 lang_oid = 2 [json_name = "langOid"];
inline void InlineCodeBlock::clear_lang_oid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.lang_oid_ = 0u;
}
inline ::uint32_t InlineCodeBlock::lang_oid() const {
  // @@protoc_insertion_point(field_get:pg_query.InlineCodeBlock.lang_oid)
  return _internal_lang_oid();
}
inline void InlineCodeBlock::set_lang_oid(::uint32_t value) {
  _internal_set_lang_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.InlineCodeBlock.lang_oid)
}
inline ::uint32_t InlineCodeBlock::_internal_lang_oid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.lang_oid_;
}
inline void InlineCodeBlock::_internal_set_lang_oid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.lang_oid_ = value;
}

// bool lang_is_trusted = 3 [json_name = "langIsTrusted"];
inline void InlineCodeBlock::clear_lang_is_trusted() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.lang_is_trusted_ = false;
}
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::set_lang_is_trusted(bool value) {
  _internal_set_lang_is_trusted(value);
  // @@protoc_insertion_point(field_set:pg_query.InlineCodeBlock.lang_is_trusted)
}
inline bool InlineCodeBlock::_internal_lang_is_trusted() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.lang_is_trusted_;
}
inline void InlineCodeBlock::_internal_set_lang_is_trusted(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.lang_is_trusted_ = value;
}

// bool atomic = 4 [json_name = "atomic"];
inline void InlineCodeBlock::clear_atomic() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.atomic_ = false;
}
inline bool InlineCodeBlock::atomic() const {
  // @@protoc_insertion_point(field_get:pg_query.InlineCodeBlock.atomic)
  return _internal_atomic();
}
inline void InlineCodeBlock::set_atomic(bool value) {
  _internal_set_atomic(value);
  // @@protoc_insertion_point(field_set:pg_query.InlineCodeBlock.atomic)
}
inline bool InlineCodeBlock::_internal_atomic() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.atomic_;
}
inline void InlineCodeBlock::_internal_set_atomic(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.atomic_ = value;
}

// -------------------------------------------------------------------

// CallStmt

// .pg_query.FuncCall funccall = 1 [json_name = "funccall"];
inline bool CallStmt::has_funccall() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.funccall_ != nullptr);
  return value;
}
inline void CallStmt::clear_funccall() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.funccall_ != nullptr) _impl_.funccall_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::FuncCall& CallStmt::_internal_funccall() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::FuncCall* p = _impl_.funccall_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::FuncCall&>(::pg_query::_FuncCall_default_instance_);
}
inline const ::pg_query::FuncCall& CallStmt::funccall() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CallStmt.funccall)
  return _internal_funccall();
}
inline void CallStmt::unsafe_arena_set_allocated_funccall(::pg_query::FuncCall* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.funccall_);
  }
  _impl_.funccall_ = reinterpret_cast<::pg_query::FuncCall*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CallStmt.funccall)
}
inline ::pg_query::FuncCall* CallStmt::release_funccall() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::FuncCall* released = _impl_.funccall_;
  _impl_.funccall_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::FuncCall* CallStmt::unsafe_arena_release_funccall() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CallStmt.funccall)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::FuncCall* temp = _impl_.funccall_;
  _impl_.funccall_ = nullptr;
  return temp;
}
inline ::pg_query::FuncCall* CallStmt::_internal_mutable_funccall() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.funccall_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::FuncCall>(GetArena());
    _impl_.funccall_ = reinterpret_cast<::pg_query::FuncCall*>(p);
  }
  return _impl_.funccall_;
}
inline ::pg_query::FuncCall* CallStmt::mutable_funccall() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::FuncCall* _msg = _internal_mutable_funccall();
  // @@protoc_insertion_point(field_mutable:pg_query.CallStmt.funccall)
  return _msg;
}
inline void CallStmt::set_allocated_funccall(::pg_query::FuncCall* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::FuncCall*>(_impl_.funccall_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::FuncCall*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.funccall_ = reinterpret_cast<::pg_query::FuncCall*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CallStmt.funccall)
}

// .pg_query.FuncExpr funcexpr = 2 [json_name = "funcexpr"];
inline bool CallStmt::has_funcexpr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.funcexpr_ != nullptr);
  return value;
}
inline void CallStmt::clear_funcexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.funcexpr_ != nullptr) _impl_.funcexpr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::FuncExpr& CallStmt::_internal_funcexpr() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::FuncExpr* p = _impl_.funcexpr_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::FuncExpr&>(::pg_query::_FuncExpr_default_instance_);
}
inline const ::pg_query::FuncExpr& CallStmt::funcexpr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CallStmt.funcexpr)
  return _internal_funcexpr();
}
inline void CallStmt::unsafe_arena_set_allocated_funcexpr(::pg_query::FuncExpr* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.funcexpr_);
  }
  _impl_.funcexpr_ = reinterpret_cast<::pg_query::FuncExpr*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CallStmt.funcexpr)
}
inline ::pg_query::FuncExpr* CallStmt::release_funcexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::FuncExpr* released = _impl_.funcexpr_;
  _impl_.funcexpr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::FuncExpr* CallStmt::unsafe_arena_release_funcexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CallStmt.funcexpr)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::FuncExpr* temp = _impl_.funcexpr_;
  _impl_.funcexpr_ = nullptr;
  return temp;
}
inline ::pg_query::FuncExpr* CallStmt::_internal_mutable_funcexpr() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.funcexpr_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::FuncExpr>(GetArena());
    _impl_.funcexpr_ = reinterpret_cast<::pg_query::FuncExpr*>(p);
  }
  return _impl_.funcexpr_;
}
inline ::pg_query::FuncExpr* CallStmt::mutable_funcexpr() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::FuncExpr* _msg = _internal_mutable_funcexpr();
  // @@protoc_insertion_point(field_mutable:pg_query.CallStmt.funcexpr)
  return _msg;
}
inline void CallStmt::set_allocated_funcexpr(::pg_query::FuncExpr* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::FuncExpr*>(_impl_.funcexpr_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::FuncExpr*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.funcexpr_ = reinterpret_cast<::pg_query::FuncExpr*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CallStmt.funcexpr)
}

// repeated .pg_query.Node outargs = 3 [json_name = "outargs"];
inline int CallStmt::_internal_outargs_size() const {
  return _internal_outargs().size();
}
inline int CallStmt::outargs_size() const {
  return _internal_outargs_size();
}
inline void CallStmt::clear_outargs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.outargs_.Clear();
}
inline ::pg_query::Node* CallStmt::mutable_outargs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CallStmt.outargs)
  return _internal_mutable_outargs()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CallStmt::mutable_outargs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CallStmt.outargs)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_outargs();
}
inline const ::pg_query::Node& CallStmt::outargs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CallStmt.outargs)
  return _internal_outargs().Get(index);
}
inline ::pg_query::Node* CallStmt::add_outargs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_outargs()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CallStmt.outargs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CallStmt::outargs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CallStmt.outargs)
  return _internal_outargs();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CallStmt::_internal_outargs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.outargs_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CallStmt::_internal_mutable_outargs() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.outargs_;
}

// -------------------------------------------------------------------

// CallContext

// bool atomic = 1 [json_name = "atomic"];
inline void CallContext::clear_atomic() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.atomic_ = false;
}
inline bool CallContext::atomic() const {
  // @@protoc_insertion_point(field_get:pg_query.CallContext.atomic)
  return _internal_atomic();
}
inline void CallContext::set_atomic(bool value) {
  _internal_set_atomic(value);
  // @@protoc_insertion_point(field_set:pg_query.CallContext.atomic)
}
inline bool CallContext::_internal_atomic() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.atomic_;
}
inline void CallContext::_internal_set_atomic(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.atomic_ = value;
}

// -------------------------------------------------------------------

// RenameStmt

// .pg_query.ObjectType rename_type = 1 [json_name = "renameType"];
inline void RenameStmt::clear_rename_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rename_type_ = 0;
}
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::set_rename_type(::pg_query::ObjectType value) {
  _internal_set_rename_type(value);
  // @@protoc_insertion_point(field_set:pg_query.RenameStmt.rename_type)
}
inline ::pg_query::ObjectType RenameStmt::_internal_rename_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.rename_type_);
}
inline void RenameStmt::_internal_set_rename_type(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.rename_type_ = value;
}

// .pg_query.ObjectType relation_type = 2 [json_name = "relationType"];
inline void RenameStmt::clear_relation_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relation_type_ = 0;
}
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::set_relation_type(::pg_query::ObjectType value) {
  _internal_set_relation_type(value);
  // @@protoc_insertion_point(field_set:pg_query.RenameStmt.relation_type)
}
inline ::pg_query::ObjectType RenameStmt::_internal_relation_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.relation_type_);
}
inline void RenameStmt::_internal_set_relation_type(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.relation_type_ = value;
}

// .pg_query.RangeVar relation = 3 [json_name = "relation"];
inline bool RenameStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void RenameStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& RenameStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& RenameStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.relation)
  return _internal_relation();
}
inline void RenameStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RenameStmt.relation)
}
inline ::pg_query::RangeVar* RenameStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* RenameStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RenameStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* RenameStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* RenameStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.RenameStmt.relation)
  return _msg;
}
inline void RenameStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RenameStmt.relation)
}

// .pg_query.Node object = 4 [json_name = "object"];
inline bool RenameStmt::has_object() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.object_ != nullptr);
  return value;
}
inline void RenameStmt::clear_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.object_ != nullptr) _impl_.object_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& RenameStmt::_internal_object() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& RenameStmt::object() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.object)
  return _internal_object();
}
inline void RenameStmt::unsafe_arena_set_allocated_object(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.object_);
  }
  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RenameStmt.object)
}
inline ::pg_query::Node* RenameStmt::release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.object_;
  _impl_.object_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RenameStmt::unsafe_arena_release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RenameStmt.object)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.object_;
  _impl_.object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RenameStmt::_internal_mutable_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.object_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.object_;
}
inline ::pg_query::Node* RenameStmt::mutable_object() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_object();
  // @@protoc_insertion_point(field_mutable:pg_query.RenameStmt.object)
  return _msg;
}
inline void RenameStmt::set_allocated_object(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.object_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RenameStmt.object)
}

// string subname = 5 [json_name = "subname"];
inline void RenameStmt::clear_subname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subname_.ClearToEmpty();
}
inline const std::string& RenameStmt::subname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.subname)
  return _internal_subname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RenameStmt::set_subname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.subname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.RenameStmt.subname)
}
inline std::string* RenameStmt::mutable_subname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_subname();
  // @@protoc_insertion_point(field_mutable:pg_query.RenameStmt.subname)
  return _s;
}
inline const std::string& RenameStmt::_internal_subname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.subname_.Get();
}
inline void RenameStmt::_internal_set_subname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.subname_.Set(value, GetArena());
}
inline std::string* RenameStmt::_internal_mutable_subname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.subname_.Mutable( GetArena());
}
inline std::string* RenameStmt::release_subname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RenameStmt.subname)
  return _impl_.subname_.Release();
}
inline void RenameStmt::set_allocated_subname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.subname_.IsDefault()) {
          _impl_.subname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.RenameStmt.subname)
}

// string newname = 6 [json_name = "newname"];
inline void RenameStmt::clear_newname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.newname_.ClearToEmpty();
}
inline const std::string& RenameStmt::newname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.newname)
  return _internal_newname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RenameStmt::set_newname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.newname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.RenameStmt.newname)
}
inline std::string* RenameStmt::mutable_newname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_newname();
  // @@protoc_insertion_point(field_mutable:pg_query.RenameStmt.newname)
  return _s;
}
inline const std::string& RenameStmt::_internal_newname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.newname_.Get();
}
inline void RenameStmt::_internal_set_newname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.newname_.Set(value, GetArena());
}
inline std::string* RenameStmt::_internal_mutable_newname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.newname_.Mutable( GetArena());
}
inline std::string* RenameStmt::release_newname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RenameStmt.newname)
  return _impl_.newname_.Release();
}
inline void RenameStmt::set_allocated_newname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.newname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.newname_.IsDefault()) {
          _impl_.newname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.RenameStmt.newname)
}

// .pg_query.DropBehavior behavior = 7 [json_name = "behavior"];
inline void RenameStmt::clear_behavior() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.behavior_ = 0;
}
inline ::pg_query::DropBehavior RenameStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.behavior)
  return _internal_behavior();
}
inline void RenameStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.RenameStmt.behavior)
}
inline ::pg_query::DropBehavior RenameStmt::_internal_behavior() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::DropBehavior>(_impl_.behavior_);
}
inline void RenameStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.behavior_ = value;
}

// bool missing_ok = 8 [json_name = "missing_ok"];
inline void RenameStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool RenameStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.RenameStmt.missing_ok)
  return _internal_missing_ok();
}
inline void RenameStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.RenameStmt.missing_ok)
}
inline bool RenameStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void RenameStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// -------------------------------------------------------------------

// AlterObjectDependsStmt

// .pg_query.ObjectType object_type = 1 [json_name = "objectType"];
inline void AlterObjectDependsStmt::clear_object_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.object_type_ = 0;
}
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::set_object_type(::pg_query::ObjectType value) {
  _internal_set_object_type(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterObjectDependsStmt.object_type)
}
inline ::pg_query::ObjectType AlterObjectDependsStmt::_internal_object_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.object_type_);
}
inline void AlterObjectDependsStmt::_internal_set_object_type(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.object_type_ = value;
}

// .pg_query.RangeVar relation = 2 [json_name = "relation"];
inline bool AlterObjectDependsStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void AlterObjectDependsStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& AlterObjectDependsStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& AlterObjectDependsStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.relation)
  return _internal_relation();
}
inline void AlterObjectDependsStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectDependsStmt.relation)
}
inline ::pg_query::RangeVar* AlterObjectDependsStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* AlterObjectDependsStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterObjectDependsStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* AlterObjectDependsStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* AlterObjectDependsStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterObjectDependsStmt.relation)
  return _msg;
}
inline void AlterObjectDependsStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectDependsStmt.relation)
}

// .pg_query.Node object = 3 [json_name = "object"];
inline bool AlterObjectDependsStmt::has_object() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.object_ != nullptr);
  return value;
}
inline void AlterObjectDependsStmt::clear_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.object_ != nullptr) _impl_.object_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& AlterObjectDependsStmt::_internal_object() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterObjectDependsStmt::object() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.object)
  return _internal_object();
}
inline void AlterObjectDependsStmt::unsafe_arena_set_allocated_object(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.object_);
  }
  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectDependsStmt.object)
}
inline ::pg_query::Node* AlterObjectDependsStmt::release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.object_;
  _impl_.object_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* AlterObjectDependsStmt::unsafe_arena_release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterObjectDependsStmt.object)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.object_;
  _impl_.object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterObjectDependsStmt::_internal_mutable_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.object_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.object_;
}
inline ::pg_query::Node* AlterObjectDependsStmt::mutable_object() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_object();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterObjectDependsStmt.object)
  return _msg;
}
inline void AlterObjectDependsStmt::set_allocated_object(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.object_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectDependsStmt.object)
}

// .pg_query.String extname = 4 [json_name = "extname"];
inline bool AlterObjectDependsStmt::has_extname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.extname_ != nullptr);
  return value;
}
inline void AlterObjectDependsStmt::clear_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.extname_ != nullptr) _impl_.extname_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::String& AlterObjectDependsStmt::_internal_extname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::String* p = _impl_.extname_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::String&>(::pg_query::_String_default_instance_);
}
inline const ::pg_query::String& AlterObjectDependsStmt::extname() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.extname)
  return _internal_extname();
}
inline void AlterObjectDependsStmt::unsafe_arena_set_allocated_extname(::pg_query::String* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.extname_);
  }
  _impl_.extname_ = reinterpret_cast<::pg_query::String*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectDependsStmt.extname)
}
inline ::pg_query::String* AlterObjectDependsStmt::release_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::String* released = _impl_.extname_;
  _impl_.extname_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::String* AlterObjectDependsStmt::unsafe_arena_release_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterObjectDependsStmt.extname)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::String* temp = _impl_.extname_;
  _impl_.extname_ = nullptr;
  return temp;
}
inline ::pg_query::String* AlterObjectDependsStmt::_internal_mutable_extname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.extname_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::String>(GetArena());
    _impl_.extname_ = reinterpret_cast<::pg_query::String*>(p);
  }
  return _impl_.extname_;
}
inline ::pg_query::String* AlterObjectDependsStmt::mutable_extname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::String* _msg = _internal_mutable_extname();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterObjectDependsStmt.extname)
  return _msg;
}
inline void AlterObjectDependsStmt::set_allocated_extname(::pg_query::String* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::String*>(_impl_.extname_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::String*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.extname_ = reinterpret_cast<::pg_query::String*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectDependsStmt.extname)
}

// bool remove = 5 [json_name = "remove"];
inline void AlterObjectDependsStmt::clear_remove() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.remove_ = false;
}
inline bool AlterObjectDependsStmt::remove() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.remove)
  return _internal_remove();
}
inline void AlterObjectDependsStmt::set_remove(bool value) {
  _internal_set_remove(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterObjectDependsStmt.remove)
}
inline bool AlterObjectDependsStmt::_internal_remove() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.remove_;
}
inline void AlterObjectDependsStmt::_internal_set_remove(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.remove_ = value;
}

// -------------------------------------------------------------------

// AlterObjectSchemaStmt

// .pg_query.ObjectType object_type = 1 [json_name = "objectType"];
inline void AlterObjectSchemaStmt::clear_object_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.object_type_ = 0;
}
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::set_object_type(::pg_query::ObjectType value) {
  _internal_set_object_type(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterObjectSchemaStmt.object_type)
}
inline ::pg_query::ObjectType AlterObjectSchemaStmt::_internal_object_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.object_type_);
}
inline void AlterObjectSchemaStmt::_internal_set_object_type(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.object_type_ = value;
}

// .pg_query.RangeVar relation = 2 [json_name = "relation"];
inline bool AlterObjectSchemaStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void AlterObjectSchemaStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& AlterObjectSchemaStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& AlterObjectSchemaStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.relation)
  return _internal_relation();
}
inline void AlterObjectSchemaStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectSchemaStmt.relation)
}
inline ::pg_query::RangeVar* AlterObjectSchemaStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* AlterObjectSchemaStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterObjectSchemaStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* AlterObjectSchemaStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* AlterObjectSchemaStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterObjectSchemaStmt.relation)
  return _msg;
}
inline void AlterObjectSchemaStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectSchemaStmt.relation)
}

// .pg_query.Node object = 3 [json_name = "object"];
inline bool AlterObjectSchemaStmt::has_object() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.object_ != nullptr);
  return value;
}
inline void AlterObjectSchemaStmt::clear_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.object_ != nullptr) _impl_.object_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& AlterObjectSchemaStmt::_internal_object() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterObjectSchemaStmt::object() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.object)
  return _internal_object();
}
inline void AlterObjectSchemaStmt::unsafe_arena_set_allocated_object(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.object_);
  }
  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectSchemaStmt.object)
}
inline ::pg_query::Node* AlterObjectSchemaStmt::release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.object_;
  _impl_.object_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* AlterObjectSchemaStmt::unsafe_arena_release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterObjectSchemaStmt.object)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.object_;
  _impl_.object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterObjectSchemaStmt::_internal_mutable_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.object_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.object_;
}
inline ::pg_query::Node* AlterObjectSchemaStmt::mutable_object() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_object();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterObjectSchemaStmt.object)
  return _msg;
}
inline void AlterObjectSchemaStmt::set_allocated_object(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.object_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectSchemaStmt.object)
}

// string newschema = 4 [json_name = "newschema"];
inline void AlterObjectSchemaStmt::clear_newschema() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.newschema_.ClearToEmpty();
}
inline const std::string& AlterObjectSchemaStmt::newschema() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.newschema)
  return _internal_newschema();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterObjectSchemaStmt::set_newschema(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.newschema_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterObjectSchemaStmt.newschema)
}
inline std::string* AlterObjectSchemaStmt::mutable_newschema() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_newschema();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterObjectSchemaStmt.newschema)
  return _s;
}
inline const std::string& AlterObjectSchemaStmt::_internal_newschema() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.newschema_.Get();
}
inline void AlterObjectSchemaStmt::_internal_set_newschema(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.newschema_.Set(value, GetArena());
}
inline std::string* AlterObjectSchemaStmt::_internal_mutable_newschema() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.newschema_.Mutable( GetArena());
}
inline std::string* AlterObjectSchemaStmt::release_newschema() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterObjectSchemaStmt.newschema)
  return _impl_.newschema_.Release();
}
inline void AlterObjectSchemaStmt::set_allocated_newschema(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.newschema_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.newschema_.IsDefault()) {
          _impl_.newschema_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectSchemaStmt.newschema)
}

// bool missing_ok = 5 [json_name = "missing_ok"];
inline void AlterObjectSchemaStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool AlterObjectSchemaStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.missing_ok)
  return _internal_missing_ok();
}
inline void AlterObjectSchemaStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterObjectSchemaStmt.missing_ok)
}
inline bool AlterObjectSchemaStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void AlterObjectSchemaStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// -------------------------------------------------------------------

// AlterOwnerStmt

// .pg_query.ObjectType object_type = 1 [json_name = "objectType"];
inline void AlterOwnerStmt::clear_object_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.object_type_ = 0;
}
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::set_object_type(::pg_query::ObjectType value) {
  _internal_set_object_type(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterOwnerStmt.object_type)
}
inline ::pg_query::ObjectType AlterOwnerStmt::_internal_object_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.object_type_);
}
inline void AlterOwnerStmt::_internal_set_object_type(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.object_type_ = value;
}

// .pg_query.RangeVar relation = 2 [json_name = "relation"];
inline bool AlterOwnerStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void AlterOwnerStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& AlterOwnerStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& AlterOwnerStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterOwnerStmt.relation)
  return _internal_relation();
}
inline void AlterOwnerStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterOwnerStmt.relation)
}
inline ::pg_query::RangeVar* AlterOwnerStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* AlterOwnerStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterOwnerStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* AlterOwnerStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* AlterOwnerStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOwnerStmt.relation)
  return _msg;
}
inline void AlterOwnerStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOwnerStmt.relation)
}

// .pg_query.Node object = 3 [json_name = "object"];
inline bool AlterOwnerStmt::has_object() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.object_ != nullptr);
  return value;
}
inline void AlterOwnerStmt::clear_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.object_ != nullptr) _impl_.object_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& AlterOwnerStmt::_internal_object() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.object_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& AlterOwnerStmt::object() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterOwnerStmt.object)
  return _internal_object();
}
inline void AlterOwnerStmt::unsafe_arena_set_allocated_object(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.object_);
  }
  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterOwnerStmt.object)
}
inline ::pg_query::Node* AlterOwnerStmt::release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.object_;
  _impl_.object_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* AlterOwnerStmt::unsafe_arena_release_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterOwnerStmt.object)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.object_;
  _impl_.object_ = nullptr;
  return temp;
}
inline ::pg_query::Node* AlterOwnerStmt::_internal_mutable_object() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.object_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.object_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.object_;
}
inline ::pg_query::Node* AlterOwnerStmt::mutable_object() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_object();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOwnerStmt.object)
  return _msg;
}
inline void AlterOwnerStmt::set_allocated_object(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.object_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.object_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOwnerStmt.object)
}

// .pg_query.RoleSpec newowner = 4 [json_name = "newowner"];
inline bool AlterOwnerStmt::has_newowner() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.newowner_ != nullptr);
  return value;
}
inline void AlterOwnerStmt::clear_newowner() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.newowner_ != nullptr) _impl_.newowner_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::RoleSpec& AlterOwnerStmt::_internal_newowner() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RoleSpec* p = _impl_.newowner_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& AlterOwnerStmt::newowner() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterOwnerStmt.newowner)
  return _internal_newowner();
}
inline void AlterOwnerStmt::unsafe_arena_set_allocated_newowner(::pg_query::RoleSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.newowner_);
  }
  _impl_.newowner_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterOwnerStmt.newowner)
}
inline ::pg_query::RoleSpec* AlterOwnerStmt::release_newowner() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::RoleSpec* released = _impl_.newowner_;
  _impl_.newowner_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RoleSpec* AlterOwnerStmt::unsafe_arena_release_newowner() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterOwnerStmt.newowner)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::RoleSpec* temp = _impl_.newowner_;
  _impl_.newowner_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* AlterOwnerStmt::_internal_mutable_newowner() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.newowner_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    _impl_.newowner_ = reinterpret_cast<::pg_query::RoleSpec*>(p);
  }
  return _impl_.newowner_;
}
inline ::pg_query::RoleSpec* AlterOwnerStmt::mutable_newowner() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_newowner();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOwnerStmt.newowner)
  return _msg;
}
inline void AlterOwnerStmt::set_allocated_newowner(::pg_query::RoleSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RoleSpec*>(_impl_.newowner_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RoleSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.newowner_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOwnerStmt.newowner)
}

// -------------------------------------------------------------------

// AlterOperatorStmt

// .pg_query.ObjectWithArgs opername = 1 [json_name = "opername"];
inline bool AlterOperatorStmt::has_opername() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.opername_ != nullptr);
  return value;
}
inline void AlterOperatorStmt::clear_opername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.opername_ != nullptr) _impl_.opername_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::ObjectWithArgs& AlterOperatorStmt::_internal_opername() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::ObjectWithArgs* p = _impl_.opername_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::ObjectWithArgs&>(::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& AlterOperatorStmt::opername() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterOperatorStmt.opername)
  return _internal_opername();
}
inline void AlterOperatorStmt::unsafe_arena_set_allocated_opername(::pg_query::ObjectWithArgs* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.opername_);
  }
  _impl_.opername_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterOperatorStmt.opername)
}
inline ::pg_query::ObjectWithArgs* AlterOperatorStmt::release_opername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::ObjectWithArgs* released = _impl_.opername_;
  _impl_.opername_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::ObjectWithArgs* AlterOperatorStmt::unsafe_arena_release_opername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterOperatorStmt.opername)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::ObjectWithArgs* temp = _impl_.opername_;
  _impl_.opername_ = nullptr;
  return temp;
}
inline ::pg_query::ObjectWithArgs* AlterOperatorStmt::_internal_mutable_opername() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.opername_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
    _impl_.opername_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(p);
  }
  return _impl_.opername_;
}
inline ::pg_query::ObjectWithArgs* AlterOperatorStmt::mutable_opername() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ObjectWithArgs* _msg = _internal_mutable_opername();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOperatorStmt.opername)
  return _msg;
}
inline void AlterOperatorStmt::set_allocated_opername(::pg_query::ObjectWithArgs* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::ObjectWithArgs*>(_impl_.opername_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::ObjectWithArgs*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.opername_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(value);
  // @@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 _internal_options().size();
}
inline int AlterOperatorStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterOperatorStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterOperatorStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterOperatorStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterOperatorStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterOperatorStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterOperatorStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterOperatorStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterOperatorStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterOperatorStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterOperatorStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterOperatorStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterOperatorStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterOperatorStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// AlterTypeStmt

// repeated .pg_query.Node type_name = 1 [json_name = "typeName"];
inline int AlterTypeStmt::_internal_type_name_size() const {
  return _internal_type_name().size();
}
inline int AlterTypeStmt::type_name_size() const {
  return _internal_type_name_size();
}
inline void AlterTypeStmt::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_name_.Clear();
}
inline ::pg_query::Node* AlterTypeStmt::mutable_type_name(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTypeStmt.type_name)
  return _internal_mutable_type_name()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterTypeStmt::mutable_type_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTypeStmt.type_name)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_type_name();
}
inline const ::pg_query::Node& AlterTypeStmt::type_name(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTypeStmt.type_name)
  return _internal_type_name().Get(index);
}
inline ::pg_query::Node* AlterTypeStmt::add_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_type_name()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterTypeStmt.type_name)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterTypeStmt::type_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterTypeStmt.type_name)
  return _internal_type_name();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterTypeStmt::_internal_type_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_name_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterTypeStmt::_internal_mutable_type_name() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.type_name_;
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int AlterTypeStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int AlterTypeStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterTypeStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterTypeStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTypeStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterTypeStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTypeStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterTypeStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTypeStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterTypeStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterTypeStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterTypeStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterTypeStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterTypeStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterTypeStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// RuleStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool RuleStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void RuleStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& RuleStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& RuleStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.relation)
  return _internal_relation();
}
inline void RuleStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RuleStmt.relation)
}
inline ::pg_query::RangeVar* RuleStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* RuleStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RuleStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* RuleStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* RuleStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.RuleStmt.relation)
  return _msg;
}
inline void RuleStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RuleStmt.relation)
}

// string rulename = 2 [json_name = "rulename"];
inline void RuleStmt::clear_rulename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rulename_.ClearToEmpty();
}
inline const std::string& RuleStmt::rulename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.rulename)
  return _internal_rulename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void RuleStmt::set_rulename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.rulename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.RuleStmt.rulename)
}
inline std::string* RuleStmt::mutable_rulename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_rulename();
  // @@protoc_insertion_point(field_mutable:pg_query.RuleStmt.rulename)
  return _s;
}
inline const std::string& RuleStmt::_internal_rulename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.rulename_.Get();
}
inline void RuleStmt::_internal_set_rulename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.rulename_.Set(value, GetArena());
}
inline std::string* RuleStmt::_internal_mutable_rulename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.rulename_.Mutable( GetArena());
}
inline std::string* RuleStmt::release_rulename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RuleStmt.rulename)
  return _impl_.rulename_.Release();
}
inline void RuleStmt::set_allocated_rulename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rulename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.rulename_.IsDefault()) {
          _impl_.rulename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.RuleStmt.rulename)
}

// .pg_query.Node where_clause = 3 [json_name = "whereClause"];
inline bool RuleStmt::has_where_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.where_clause_ != nullptr);
  return value;
}
inline void RuleStmt::clear_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.where_clause_ != nullptr) _impl_.where_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& RuleStmt::_internal_where_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.where_clause_);
  }
  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RuleStmt.where_clause)
}
inline ::pg_query::Node* RuleStmt::release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* RuleStmt::unsafe_arena_release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RuleStmt.where_clause)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* RuleStmt::_internal_mutable_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.where_clause_;
}
inline ::pg_query::Node* RuleStmt::mutable_where_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_where_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.RuleStmt.where_clause)
  return _msg;
}
inline void RuleStmt::set_allocated_where_clause(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.where_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RuleStmt.where_clause)
}

// .pg_query.CmdType event = 4 [json_name = "event"];
inline void RuleStmt::clear_event() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.event_ = 0;
}
inline ::pg_query::CmdType RuleStmt::event() const {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.event)
  return _internal_event();
}
inline void RuleStmt::set_event(::pg_query::CmdType value) {
  _internal_set_event(value);
  // @@protoc_insertion_point(field_set:pg_query.RuleStmt.event)
}
inline ::pg_query::CmdType RuleStmt::_internal_event() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CmdType>(_impl_.event_);
}
inline void RuleStmt::_internal_set_event(::pg_query::CmdType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.event_ = value;
}

// bool instead = 5 [json_name = "instead"];
inline void RuleStmt::clear_instead() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.instead_ = false;
}
inline bool RuleStmt::instead() const {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.instead)
  return _internal_instead();
}
inline void RuleStmt::set_instead(bool value) {
  _internal_set_instead(value);
  // @@protoc_insertion_point(field_set:pg_query.RuleStmt.instead)
}
inline bool RuleStmt::_internal_instead() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.instead_;
}
inline void RuleStmt::_internal_set_instead(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.instead_ = value;
}

// repeated .pg_query.Node actions = 6 [json_name = "actions"];
inline int RuleStmt::_internal_actions_size() const {
  return _internal_actions().size();
}
inline int RuleStmt::actions_size() const {
  return _internal_actions_size();
}
inline void RuleStmt::clear_actions() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.actions_.Clear();
}
inline ::pg_query::Node* RuleStmt::mutable_actions(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.RuleStmt.actions)
  return _internal_mutable_actions()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* RuleStmt::mutable_actions()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.RuleStmt.actions)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_actions();
}
inline const ::pg_query::Node& RuleStmt::actions(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.actions)
  return _internal_actions().Get(index);
}
inline ::pg_query::Node* RuleStmt::add_actions() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_actions()->Add();
  // @@protoc_insertion_point(field_add:pg_query.RuleStmt.actions)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& RuleStmt::actions() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.RuleStmt.actions)
  return _internal_actions();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
RuleStmt::_internal_actions() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.actions_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
RuleStmt::_internal_mutable_actions() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.actions_;
}

// bool replace = 7 [json_name = "replace"];
inline void RuleStmt::clear_replace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.replace_ = false;
}
inline bool RuleStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.RuleStmt.replace)
  return _internal_replace();
}
inline void RuleStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.RuleStmt.replace)
}
inline bool RuleStmt::_internal_replace() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.replace_;
}
inline void RuleStmt::_internal_set_replace(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.replace_ = value;
}

// -------------------------------------------------------------------

// NotifyStmt

// string conditionname = 1 [json_name = "conditionname"];
inline void NotifyStmt::clear_conditionname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conditionname_.ClearToEmpty();
}
inline const std::string& NotifyStmt::conditionname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.NotifyStmt.conditionname)
  return _internal_conditionname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void NotifyStmt::set_conditionname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conditionname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.NotifyStmt.conditionname)
}
inline std::string* NotifyStmt::mutable_conditionname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_conditionname();
  // @@protoc_insertion_point(field_mutable:pg_query.NotifyStmt.conditionname)
  return _s;
}
inline const std::string& NotifyStmt::_internal_conditionname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.conditionname_.Get();
}
inline void NotifyStmt::_internal_set_conditionname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conditionname_.Set(value, GetArena());
}
inline std::string* NotifyStmt::_internal_mutable_conditionname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.conditionname_.Mutable( GetArena());
}
inline std::string* NotifyStmt::release_conditionname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.NotifyStmt.conditionname)
  return _impl_.conditionname_.Release();
}
inline void NotifyStmt::set_allocated_conditionname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conditionname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.conditionname_.IsDefault()) {
          _impl_.conditionname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.NotifyStmt.conditionname)
}

// string payload = 2 [json_name = "payload"];
inline void NotifyStmt::clear_payload() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.payload_.ClearToEmpty();
}
inline const std::string& NotifyStmt::payload() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.NotifyStmt.payload)
  return _internal_payload();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void NotifyStmt::set_payload(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.payload_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.NotifyStmt.payload)
}
inline std::string* NotifyStmt::mutable_payload() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_payload();
  // @@protoc_insertion_point(field_mutable:pg_query.NotifyStmt.payload)
  return _s;
}
inline const std::string& NotifyStmt::_internal_payload() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.payload_.Get();
}
inline void NotifyStmt::_internal_set_payload(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.payload_.Set(value, GetArena());
}
inline std::string* NotifyStmt::_internal_mutable_payload() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.payload_.Mutable( GetArena());
}
inline std::string* NotifyStmt::release_payload() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.NotifyStmt.payload)
  return _impl_.payload_.Release();
}
inline void NotifyStmt::set_allocated_payload(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.payload_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.payload_.IsDefault()) {
          _impl_.payload_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.NotifyStmt.payload)
}

// -------------------------------------------------------------------

// ListenStmt

// string conditionname = 1 [json_name = "conditionname"];
inline void ListenStmt::clear_conditionname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conditionname_.ClearToEmpty();
}
inline const std::string& ListenStmt::conditionname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ListenStmt.conditionname)
  return _internal_conditionname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ListenStmt::set_conditionname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conditionname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ListenStmt.conditionname)
}
inline std::string* ListenStmt::mutable_conditionname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_conditionname();
  // @@protoc_insertion_point(field_mutable:pg_query.ListenStmt.conditionname)
  return _s;
}
inline const std::string& ListenStmt::_internal_conditionname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.conditionname_.Get();
}
inline void ListenStmt::_internal_set_conditionname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conditionname_.Set(value, GetArena());
}
inline std::string* ListenStmt::_internal_mutable_conditionname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.conditionname_.Mutable( GetArena());
}
inline std::string* ListenStmt::release_conditionname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ListenStmt.conditionname)
  return _impl_.conditionname_.Release();
}
inline void ListenStmt::set_allocated_conditionname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conditionname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.conditionname_.IsDefault()) {
          _impl_.conditionname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.ListenStmt.conditionname)
}

// -------------------------------------------------------------------

// UnlistenStmt

// string conditionname = 1 [json_name = "conditionname"];
inline void UnlistenStmt::clear_conditionname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conditionname_.ClearToEmpty();
}
inline const std::string& UnlistenStmt::conditionname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.UnlistenStmt.conditionname)
  return _internal_conditionname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void UnlistenStmt::set_conditionname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conditionname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.UnlistenStmt.conditionname)
}
inline std::string* UnlistenStmt::mutable_conditionname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_conditionname();
  // @@protoc_insertion_point(field_mutable:pg_query.UnlistenStmt.conditionname)
  return _s;
}
inline const std::string& UnlistenStmt::_internal_conditionname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.conditionname_.Get();
}
inline void UnlistenStmt::_internal_set_conditionname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conditionname_.Set(value, GetArena());
}
inline std::string* UnlistenStmt::_internal_mutable_conditionname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.conditionname_.Mutable( GetArena());
}
inline std::string* UnlistenStmt::release_conditionname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.UnlistenStmt.conditionname)
  return _impl_.conditionname_.Release();
}
inline void UnlistenStmt::set_allocated_conditionname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conditionname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.conditionname_.IsDefault()) {
          _impl_.conditionname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.UnlistenStmt.conditionname)
}

// -------------------------------------------------------------------

// TransactionStmt

// .pg_query.TransactionStmtKind kind = 1 [json_name = "kind"];
inline void TransactionStmt::clear_kind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.kind_ = 0;
}
inline ::pg_query::TransactionStmtKind TransactionStmt::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.kind)
  return _internal_kind();
}
inline void TransactionStmt::set_kind(::pg_query::TransactionStmtKind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.TransactionStmt.kind)
}
inline ::pg_query::TransactionStmtKind TransactionStmt::_internal_kind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::TransactionStmtKind>(_impl_.kind_);
}
inline void TransactionStmt::_internal_set_kind(::pg_query::TransactionStmtKind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.kind_ = value;
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int TransactionStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int TransactionStmt::options_size() const {
  return _internal_options_size();
}
inline void TransactionStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* TransactionStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.TransactionStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* TransactionStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.TransactionStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& TransactionStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* TransactionStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.TransactionStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& TransactionStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.TransactionStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
TransactionStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
TransactionStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// string savepoint_name = 3 [json_name = "savepoint_name"];
inline void TransactionStmt::clear_savepoint_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.savepoint_name_.ClearToEmpty();
}
inline const std::string& TransactionStmt::savepoint_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.savepoint_name)
  return _internal_savepoint_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void TransactionStmt::set_savepoint_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.savepoint_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.TransactionStmt.savepoint_name)
}
inline std::string* TransactionStmt::mutable_savepoint_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_savepoint_name();
  // @@protoc_insertion_point(field_mutable:pg_query.TransactionStmt.savepoint_name)
  return _s;
}
inline const std::string& TransactionStmt::_internal_savepoint_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.savepoint_name_.Get();
}
inline void TransactionStmt::_internal_set_savepoint_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.savepoint_name_.Set(value, GetArena());
}
inline std::string* TransactionStmt::_internal_mutable_savepoint_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.savepoint_name_.Mutable( GetArena());
}
inline std::string* TransactionStmt::release_savepoint_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.TransactionStmt.savepoint_name)
  return _impl_.savepoint_name_.Release();
}
inline void TransactionStmt::set_allocated_savepoint_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.savepoint_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.savepoint_name_.IsDefault()) {
          _impl_.savepoint_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.TransactionStmt.savepoint_name)
}

// string gid = 4 [json_name = "gid"];
inline void TransactionStmt::clear_gid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.gid_.ClearToEmpty();
}
inline const std::string& TransactionStmt::gid() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.gid)
  return _internal_gid();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void TransactionStmt::set_gid(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.gid_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.TransactionStmt.gid)
}
inline std::string* TransactionStmt::mutable_gid() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_gid();
  // @@protoc_insertion_point(field_mutable:pg_query.TransactionStmt.gid)
  return _s;
}
inline const std::string& TransactionStmt::_internal_gid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.gid_.Get();
}
inline void TransactionStmt::_internal_set_gid(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.gid_.Set(value, GetArena());
}
inline std::string* TransactionStmt::_internal_mutable_gid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.gid_.Mutable( GetArena());
}
inline std::string* TransactionStmt::release_gid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.TransactionStmt.gid)
  return _impl_.gid_.Release();
}
inline void TransactionStmt::set_allocated_gid(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.gid_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.gid_.IsDefault()) {
          _impl_.gid_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.TransactionStmt.gid)
}

// bool chain = 5 [json_name = "chain"];
inline void TransactionStmt::clear_chain() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.chain_ = false;
}
inline bool TransactionStmt::chain() const {
  // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.chain)
  return _internal_chain();
}
inline void TransactionStmt::set_chain(bool value) {
  _internal_set_chain(value);
  // @@protoc_insertion_point(field_set:pg_query.TransactionStmt.chain)
}
inline bool TransactionStmt::_internal_chain() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.chain_;
}
inline void TransactionStmt::_internal_set_chain(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.chain_ = value;
}

// -------------------------------------------------------------------

// CompositeTypeStmt

// .pg_query.RangeVar typevar = 1 [json_name = "typevar"];
inline bool CompositeTypeStmt::has_typevar() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.typevar_ != nullptr);
  return value;
}
inline void CompositeTypeStmt::clear_typevar() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.typevar_ != nullptr) _impl_.typevar_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& CompositeTypeStmt::_internal_typevar() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.typevar_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& CompositeTypeStmt::typevar() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CompositeTypeStmt.typevar)
  return _internal_typevar();
}
inline void CompositeTypeStmt::unsafe_arena_set_allocated_typevar(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.typevar_);
  }
  _impl_.typevar_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CompositeTypeStmt.typevar)
}
inline ::pg_query::RangeVar* CompositeTypeStmt::release_typevar() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.typevar_;
  _impl_.typevar_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* CompositeTypeStmt::unsafe_arena_release_typevar() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CompositeTypeStmt.typevar)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.typevar_;
  _impl_.typevar_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* CompositeTypeStmt::_internal_mutable_typevar() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.typevar_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.typevar_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.typevar_;
}
inline ::pg_query::RangeVar* CompositeTypeStmt::mutable_typevar() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_typevar();
  // @@protoc_insertion_point(field_mutable:pg_query.CompositeTypeStmt.typevar)
  return _msg;
}
inline void CompositeTypeStmt::set_allocated_typevar(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.typevar_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.typevar_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@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 _internal_coldeflist().size();
}
inline int CompositeTypeStmt::coldeflist_size() const {
  return _internal_coldeflist_size();
}
inline void CompositeTypeStmt::clear_coldeflist() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.coldeflist_.Clear();
}
inline ::pg_query::Node* CompositeTypeStmt::mutable_coldeflist(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CompositeTypeStmt.coldeflist)
  return _internal_mutable_coldeflist()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CompositeTypeStmt::mutable_coldeflist()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CompositeTypeStmt.coldeflist)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_coldeflist();
}
inline const ::pg_query::Node& CompositeTypeStmt::coldeflist(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CompositeTypeStmt.coldeflist)
  return _internal_coldeflist().Get(index);
}
inline ::pg_query::Node* CompositeTypeStmt::add_coldeflist() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_coldeflist()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CompositeTypeStmt.coldeflist)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CompositeTypeStmt::coldeflist() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CompositeTypeStmt.coldeflist)
  return _internal_coldeflist();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CompositeTypeStmt::_internal_coldeflist() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.coldeflist_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CompositeTypeStmt::_internal_mutable_coldeflist() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.coldeflist_;
}

// -------------------------------------------------------------------

// CreateEnumStmt

// repeated .pg_query.Node type_name = 1 [json_name = "typeName"];
inline int CreateEnumStmt::_internal_type_name_size() const {
  return _internal_type_name().size();
}
inline int CreateEnumStmt::type_name_size() const {
  return _internal_type_name_size();
}
inline void CreateEnumStmt::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_name_.Clear();
}
inline ::pg_query::Node* CreateEnumStmt::mutable_type_name(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateEnumStmt.type_name)
  return _internal_mutable_type_name()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateEnumStmt::mutable_type_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateEnumStmt.type_name)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_type_name();
}
inline const ::pg_query::Node& CreateEnumStmt::type_name(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateEnumStmt.type_name)
  return _internal_type_name().Get(index);
}
inline ::pg_query::Node* CreateEnumStmt::add_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_type_name()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateEnumStmt.type_name)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateEnumStmt::type_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateEnumStmt.type_name)
  return _internal_type_name();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateEnumStmt::_internal_type_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_name_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateEnumStmt::_internal_mutable_type_name() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.type_name_;
}

// repeated .pg_query.Node vals = 2 [json_name = "vals"];
inline int CreateEnumStmt::_internal_vals_size() const {
  return _internal_vals().size();
}
inline int CreateEnumStmt::vals_size() const {
  return _internal_vals_size();
}
inline void CreateEnumStmt::clear_vals() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.vals_.Clear();
}
inline ::pg_query::Node* CreateEnumStmt::mutable_vals(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateEnumStmt.vals)
  return _internal_mutable_vals()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateEnumStmt::mutable_vals()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateEnumStmt.vals)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_vals();
}
inline const ::pg_query::Node& CreateEnumStmt::vals(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateEnumStmt.vals)
  return _internal_vals().Get(index);
}
inline ::pg_query::Node* CreateEnumStmt::add_vals() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_vals()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateEnumStmt.vals)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateEnumStmt::vals() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateEnumStmt.vals)
  return _internal_vals();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateEnumStmt::_internal_vals() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.vals_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateEnumStmt::_internal_mutable_vals() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.vals_;
}

// -------------------------------------------------------------------

// CreateRangeStmt

// repeated .pg_query.Node type_name = 1 [json_name = "typeName"];
inline int CreateRangeStmt::_internal_type_name_size() const {
  return _internal_type_name().size();
}
inline int CreateRangeStmt::type_name_size() const {
  return _internal_type_name_size();
}
inline void CreateRangeStmt::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_name_.Clear();
}
inline ::pg_query::Node* CreateRangeStmt::mutable_type_name(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateRangeStmt.type_name)
  return _internal_mutable_type_name()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateRangeStmt::mutable_type_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateRangeStmt.type_name)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_type_name();
}
inline const ::pg_query::Node& CreateRangeStmt::type_name(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateRangeStmt.type_name)
  return _internal_type_name().Get(index);
}
inline ::pg_query::Node* CreateRangeStmt::add_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_type_name()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateRangeStmt.type_name)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateRangeStmt::type_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateRangeStmt.type_name)
  return _internal_type_name();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateRangeStmt::_internal_type_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_name_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateRangeStmt::_internal_mutable_type_name() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.type_name_;
}

// repeated .pg_query.Node params = 2 [json_name = "params"];
inline int CreateRangeStmt::_internal_params_size() const {
  return _internal_params().size();
}
inline int CreateRangeStmt::params_size() const {
  return _internal_params_size();
}
inline void CreateRangeStmt::clear_params() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.params_.Clear();
}
inline ::pg_query::Node* CreateRangeStmt::mutable_params(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateRangeStmt.params)
  return _internal_mutable_params()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateRangeStmt::mutable_params()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateRangeStmt.params)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_params();
}
inline const ::pg_query::Node& CreateRangeStmt::params(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateRangeStmt.params)
  return _internal_params().Get(index);
}
inline ::pg_query::Node* CreateRangeStmt::add_params() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_params()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateRangeStmt.params)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateRangeStmt::params() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateRangeStmt.params)
  return _internal_params();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateRangeStmt::_internal_params() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.params_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateRangeStmt::_internal_mutable_params() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.params_;
}

// -------------------------------------------------------------------

// AlterEnumStmt

// repeated .pg_query.Node type_name = 1 [json_name = "typeName"];
inline int AlterEnumStmt::_internal_type_name_size() const {
  return _internal_type_name().size();
}
inline int AlterEnumStmt::type_name_size() const {
  return _internal_type_name_size();
}
inline void AlterEnumStmt::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_name_.Clear();
}
inline ::pg_query::Node* AlterEnumStmt::mutable_type_name(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterEnumStmt.type_name)
  return _internal_mutable_type_name()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterEnumStmt::mutable_type_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterEnumStmt.type_name)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_type_name();
}
inline const ::pg_query::Node& AlterEnumStmt::type_name(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.type_name)
  return _internal_type_name().Get(index);
}
inline ::pg_query::Node* AlterEnumStmt::add_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_type_name()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterEnumStmt.type_name)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterEnumStmt::type_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterEnumStmt.type_name)
  return _internal_type_name();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterEnumStmt::_internal_type_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_name_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterEnumStmt::_internal_mutable_type_name() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.type_name_;
}

// string old_val = 2 [json_name = "oldVal"];
inline void AlterEnumStmt::clear_old_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.old_val_.ClearToEmpty();
}
inline const std::string& AlterEnumStmt::old_val() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.old_val)
  return _internal_old_val();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterEnumStmt::set_old_val(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.old_val_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.old_val)
}
inline std::string* AlterEnumStmt::mutable_old_val() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_old_val();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterEnumStmt.old_val)
  return _s;
}
inline const std::string& AlterEnumStmt::_internal_old_val() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.old_val_.Get();
}
inline void AlterEnumStmt::_internal_set_old_val(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.old_val_.Set(value, GetArena());
}
inline std::string* AlterEnumStmt::_internal_mutable_old_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.old_val_.Mutable( GetArena());
}
inline std::string* AlterEnumStmt::release_old_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterEnumStmt.old_val)
  return _impl_.old_val_.Release();
}
inline void AlterEnumStmt::set_allocated_old_val(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.old_val_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.old_val_.IsDefault()) {
          _impl_.old_val_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterEnumStmt.old_val)
}

// string new_val = 3 [json_name = "newVal"];
inline void AlterEnumStmt::clear_new_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.new_val_.ClearToEmpty();
}
inline const std::string& AlterEnumStmt::new_val() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.new_val)
  return _internal_new_val();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterEnumStmt::set_new_val(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.new_val_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.new_val)
}
inline std::string* AlterEnumStmt::mutable_new_val() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_new_val();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterEnumStmt.new_val)
  return _s;
}
inline const std::string& AlterEnumStmt::_internal_new_val() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.new_val_.Get();
}
inline void AlterEnumStmt::_internal_set_new_val(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.new_val_.Set(value, GetArena());
}
inline std::string* AlterEnumStmt::_internal_mutable_new_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.new_val_.Mutable( GetArena());
}
inline std::string* AlterEnumStmt::release_new_val() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterEnumStmt.new_val)
  return _impl_.new_val_.Release();
}
inline void AlterEnumStmt::set_allocated_new_val(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.new_val_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.new_val_.IsDefault()) {
          _impl_.new_val_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.new_val_neighbor_.ClearToEmpty();
}
inline const std::string& AlterEnumStmt::new_val_neighbor() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.new_val_neighbor)
  return _internal_new_val_neighbor();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterEnumStmt::set_new_val_neighbor(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.new_val_neighbor_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.new_val_neighbor)
}
inline std::string* AlterEnumStmt::mutable_new_val_neighbor() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_new_val_neighbor();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterEnumStmt.new_val_neighbor)
  return _s;
}
inline const std::string& AlterEnumStmt::_internal_new_val_neighbor() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.new_val_neighbor_.Get();
}
inline void AlterEnumStmt::_internal_set_new_val_neighbor(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.new_val_neighbor_.Set(value, GetArena());
}
inline std::string* AlterEnumStmt::_internal_mutable_new_val_neighbor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.new_val_neighbor_.Mutable( GetArena());
}
inline std::string* AlterEnumStmt::release_new_val_neighbor() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterEnumStmt.new_val_neighbor)
  return _impl_.new_val_neighbor_.Release();
}
inline void AlterEnumStmt::set_allocated_new_val_neighbor(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.new_val_neighbor_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.new_val_neighbor_.IsDefault()) {
          _impl_.new_val_neighbor_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.new_val_is_after_ = false;
}
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::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)
}
inline bool AlterEnumStmt::_internal_new_val_is_after() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.new_val_is_after_;
}
inline void AlterEnumStmt::_internal_set_new_val_is_after(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.new_val_is_after_ = value;
}

// bool skip_if_new_val_exists = 6 [json_name = "skipIfNewValExists"];
inline void AlterEnumStmt::clear_skip_if_new_val_exists() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.skip_if_new_val_exists_ = false;
}
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::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)
}
inline bool AlterEnumStmt::_internal_skip_if_new_val_exists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.skip_if_new_val_exists_;
}
inline void AlterEnumStmt::_internal_set_skip_if_new_val_exists(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.skip_if_new_val_exists_ = value;
}

// -------------------------------------------------------------------

// ViewStmt

// .pg_query.RangeVar view = 1 [json_name = "view"];
inline bool ViewStmt::has_view() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.view_ != nullptr);
  return value;
}
inline void ViewStmt::clear_view() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.view_ != nullptr) _impl_.view_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& ViewStmt::_internal_view() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.view_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& ViewStmt::view() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ViewStmt.view)
  return _internal_view();
}
inline void ViewStmt::unsafe_arena_set_allocated_view(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.view_);
  }
  _impl_.view_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ViewStmt.view)
}
inline ::pg_query::RangeVar* ViewStmt::release_view() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.view_;
  _impl_.view_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* ViewStmt::unsafe_arena_release_view() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ViewStmt.view)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.view_;
  _impl_.view_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* ViewStmt::_internal_mutable_view() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.view_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.view_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.view_;
}
inline ::pg_query::RangeVar* ViewStmt::mutable_view() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_view();
  // @@protoc_insertion_point(field_mutable:pg_query.ViewStmt.view)
  return _msg;
}
inline void ViewStmt::set_allocated_view(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.view_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.view_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@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 _internal_aliases().size();
}
inline int ViewStmt::aliases_size() const {
  return _internal_aliases_size();
}
inline void ViewStmt::clear_aliases() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.aliases_.Clear();
}
inline ::pg_query::Node* ViewStmt::mutable_aliases(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ViewStmt.aliases)
  return _internal_mutable_aliases()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ViewStmt::mutable_aliases()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ViewStmt.aliases)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_aliases();
}
inline const ::pg_query::Node& ViewStmt::aliases(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ViewStmt.aliases)
  return _internal_aliases().Get(index);
}
inline ::pg_query::Node* ViewStmt::add_aliases() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_aliases()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ViewStmt.aliases)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ViewStmt::aliases() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ViewStmt.aliases)
  return _internal_aliases();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ViewStmt::_internal_aliases() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.aliases_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ViewStmt::_internal_mutable_aliases() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.aliases_;
}

// .pg_query.Node query = 3 [json_name = "query"];
inline bool ViewStmt::has_query() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.query_ != nullptr);
  return value;
}
inline void ViewStmt::clear_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.query_ != nullptr) _impl_.query_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& ViewStmt::_internal_query() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ViewStmt::query() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ViewStmt.query)
  return _internal_query();
}
inline void ViewStmt::unsafe_arena_set_allocated_query(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.query_);
  }
  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ViewStmt.query)
}
inline ::pg_query::Node* ViewStmt::release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.query_;
  _impl_.query_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ViewStmt::unsafe_arena_release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ViewStmt.query)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.query_;
  _impl_.query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ViewStmt::_internal_mutable_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.query_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.query_;
}
inline ::pg_query::Node* ViewStmt::mutable_query() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_query();
  // @@protoc_insertion_point(field_mutable:pg_query.ViewStmt.query)
  return _msg;
}
inline void ViewStmt::set_allocated_query(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.query_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ViewStmt.query)
}

// bool replace = 4 [json_name = "replace"];
inline void ViewStmt::clear_replace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.replace_ = false;
}
inline bool ViewStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.ViewStmt.replace)
  return _internal_replace();
}
inline void ViewStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.ViewStmt.replace)
}
inline bool ViewStmt::_internal_replace() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.replace_;
}
inline void ViewStmt::_internal_set_replace(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.replace_ = value;
}

// repeated .pg_query.Node options = 5 [json_name = "options"];
inline int ViewStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int ViewStmt::options_size() const {
  return _internal_options_size();
}
inline void ViewStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* ViewStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ViewStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ViewStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ViewStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& ViewStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ViewStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* ViewStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ViewStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ViewStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ViewStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ViewStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ViewStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// .pg_query.ViewCheckOption with_check_option = 6 [json_name = "withCheckOption"];
inline void ViewStmt::clear_with_check_option() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.with_check_option_ = 0;
}
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::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)
}
inline ::pg_query::ViewCheckOption ViewStmt::_internal_with_check_option() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ViewCheckOption>(_impl_.with_check_option_);
}
inline void ViewStmt::_internal_set_with_check_option(::pg_query::ViewCheckOption value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.with_check_option_ = value;
}

// -------------------------------------------------------------------

// LoadStmt

// string filename = 1 [json_name = "filename"];
inline void LoadStmt::clear_filename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.filename_.ClearToEmpty();
}
inline const std::string& LoadStmt::filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.LoadStmt.filename)
  return _internal_filename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void LoadStmt::set_filename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.filename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.LoadStmt.filename)
}
inline std::string* LoadStmt::mutable_filename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:pg_query.LoadStmt.filename)
  return _s;
}
inline const std::string& LoadStmt::_internal_filename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.filename_.Get();
}
inline void LoadStmt::_internal_set_filename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.filename_.Set(value, GetArena());
}
inline std::string* LoadStmt::_internal_mutable_filename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.filename_.Mutable( GetArena());
}
inline std::string* LoadStmt::release_filename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.LoadStmt.filename)
  return _impl_.filename_.Release();
}
inline void LoadStmt::set_allocated_filename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.filename_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.filename_.IsDefault()) {
          _impl_.filename_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.LoadStmt.filename)
}

// -------------------------------------------------------------------

// CreatedbStmt

// string dbname = 1 [json_name = "dbname"];
inline void CreatedbStmt::clear_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.dbname_.ClearToEmpty();
}
inline const std::string& CreatedbStmt::dbname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatedbStmt.dbname)
  return _internal_dbname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreatedbStmt::set_dbname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.dbname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreatedbStmt.dbname)
}
inline std::string* CreatedbStmt::mutable_dbname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_dbname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreatedbStmt.dbname)
  return _s;
}
inline const std::string& CreatedbStmt::_internal_dbname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.dbname_.Get();
}
inline void CreatedbStmt::_internal_set_dbname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.dbname_.Set(value, GetArena());
}
inline std::string* CreatedbStmt::_internal_mutable_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.dbname_.Mutable( GetArena());
}
inline std::string* CreatedbStmt::release_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreatedbStmt.dbname)
  return _impl_.dbname_.Release();
}
inline void CreatedbStmt::set_allocated_dbname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.dbname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.dbname_.IsDefault()) {
          _impl_.dbname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int CreatedbStmt::options_size() const {
  return _internal_options_size();
}
inline void CreatedbStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreatedbStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatedbStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreatedbStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatedbStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreatedbStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatedbStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreatedbStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreatedbStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreatedbStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreatedbStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreatedbStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreatedbStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// AlterDatabaseStmt

// string dbname = 1 [json_name = "dbname"];
inline void AlterDatabaseStmt::clear_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.dbname_.ClearToEmpty();
}
inline const std::string& AlterDatabaseStmt::dbname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseStmt.dbname)
  return _internal_dbname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterDatabaseStmt::set_dbname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.dbname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterDatabaseStmt.dbname)
}
inline std::string* AlterDatabaseStmt::mutable_dbname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_dbname();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDatabaseStmt.dbname)
  return _s;
}
inline const std::string& AlterDatabaseStmt::_internal_dbname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.dbname_.Get();
}
inline void AlterDatabaseStmt::_internal_set_dbname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.dbname_.Set(value, GetArena());
}
inline std::string* AlterDatabaseStmt::_internal_mutable_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.dbname_.Mutable( GetArena());
}
inline std::string* AlterDatabaseStmt::release_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterDatabaseStmt.dbname)
  return _impl_.dbname_.Release();
}
inline void AlterDatabaseStmt::set_allocated_dbname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.dbname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.dbname_.IsDefault()) {
          _impl_.dbname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int AlterDatabaseStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterDatabaseStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterDatabaseStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDatabaseStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterDatabaseStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterDatabaseStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterDatabaseStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterDatabaseStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterDatabaseStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterDatabaseStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterDatabaseStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterDatabaseStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterDatabaseStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// AlterDatabaseRefreshCollStmt

// string dbname = 1 [json_name = "dbname"];
inline void AlterDatabaseRefreshCollStmt::clear_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.dbname_.ClearToEmpty();
}
inline const std::string& AlterDatabaseRefreshCollStmt::dbname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseRefreshCollStmt.dbname)
  return _internal_dbname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterDatabaseRefreshCollStmt::set_dbname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.dbname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterDatabaseRefreshCollStmt.dbname)
}
inline std::string* AlterDatabaseRefreshCollStmt::mutable_dbname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_dbname();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDatabaseRefreshCollStmt.dbname)
  return _s;
}
inline const std::string& AlterDatabaseRefreshCollStmt::_internal_dbname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.dbname_.Get();
}
inline void AlterDatabaseRefreshCollStmt::_internal_set_dbname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.dbname_.Set(value, GetArena());
}
inline std::string* AlterDatabaseRefreshCollStmt::_internal_mutable_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.dbname_.Mutable( GetArena());
}
inline std::string* AlterDatabaseRefreshCollStmt::release_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterDatabaseRefreshCollStmt.dbname)
  return _impl_.dbname_.Release();
}
inline void AlterDatabaseRefreshCollStmt::set_allocated_dbname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.dbname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.dbname_.IsDefault()) {
          _impl_.dbname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDatabaseRefreshCollStmt.dbname)
}

// -------------------------------------------------------------------

// AlterDatabaseSetStmt

// string dbname = 1 [json_name = "dbname"];
inline void AlterDatabaseSetStmt::clear_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.dbname_.ClearToEmpty();
}
inline const std::string& AlterDatabaseSetStmt::dbname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseSetStmt.dbname)
  return _internal_dbname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterDatabaseSetStmt::set_dbname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.dbname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterDatabaseSetStmt.dbname)
}
inline std::string* AlterDatabaseSetStmt::mutable_dbname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_dbname();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDatabaseSetStmt.dbname)
  return _s;
}
inline const std::string& AlterDatabaseSetStmt::_internal_dbname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.dbname_.Get();
}
inline void AlterDatabaseSetStmt::_internal_set_dbname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.dbname_.Set(value, GetArena());
}
inline std::string* AlterDatabaseSetStmt::_internal_mutable_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.dbname_.Mutable( GetArena());
}
inline std::string* AlterDatabaseSetStmt::release_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterDatabaseSetStmt.dbname)
  return _impl_.dbname_.Release();
}
inline void AlterDatabaseSetStmt::set_allocated_dbname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.dbname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.dbname_.IsDefault()) {
          _impl_.dbname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDatabaseSetStmt.dbname)
}

// .pg_query.VariableSetStmt setstmt = 2 [json_name = "setstmt"];
inline bool AlterDatabaseSetStmt::has_setstmt() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.setstmt_ != nullptr);
  return value;
}
inline void AlterDatabaseSetStmt::clear_setstmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.setstmt_ != nullptr) _impl_.setstmt_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::VariableSetStmt& AlterDatabaseSetStmt::_internal_setstmt() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::VariableSetStmt* p = _impl_.setstmt_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::VariableSetStmt&>(::pg_query::_VariableSetStmt_default_instance_);
}
inline const ::pg_query::VariableSetStmt& AlterDatabaseSetStmt::setstmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseSetStmt.setstmt)
  return _internal_setstmt();
}
inline void AlterDatabaseSetStmt::unsafe_arena_set_allocated_setstmt(::pg_query::VariableSetStmt* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.setstmt_);
  }
  _impl_.setstmt_ = reinterpret_cast<::pg_query::VariableSetStmt*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterDatabaseSetStmt.setstmt)
}
inline ::pg_query::VariableSetStmt* AlterDatabaseSetStmt::release_setstmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::VariableSetStmt* released = _impl_.setstmt_;
  _impl_.setstmt_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::VariableSetStmt* AlterDatabaseSetStmt::unsafe_arena_release_setstmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterDatabaseSetStmt.setstmt)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::VariableSetStmt* temp = _impl_.setstmt_;
  _impl_.setstmt_ = nullptr;
  return temp;
}
inline ::pg_query::VariableSetStmt* AlterDatabaseSetStmt::_internal_mutable_setstmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.setstmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::VariableSetStmt>(GetArena());
    _impl_.setstmt_ = reinterpret_cast<::pg_query::VariableSetStmt*>(p);
  }
  return _impl_.setstmt_;
}
inline ::pg_query::VariableSetStmt* AlterDatabaseSetStmt::mutable_setstmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::VariableSetStmt* _msg = _internal_mutable_setstmt();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterDatabaseSetStmt.setstmt)
  return _msg;
}
inline void AlterDatabaseSetStmt::set_allocated_setstmt(::pg_query::VariableSetStmt* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::VariableSetStmt*>(_impl_.setstmt_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::VariableSetStmt*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.setstmt_ = reinterpret_cast<::pg_query::VariableSetStmt*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDatabaseSetStmt.setstmt)
}

// -------------------------------------------------------------------

// DropdbStmt

// string dbname = 1 [json_name = "dbname"];
inline void DropdbStmt::clear_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.dbname_.ClearToEmpty();
}
inline const std::string& DropdbStmt::dbname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DropdbStmt.dbname)
  return _internal_dbname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DropdbStmt::set_dbname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.dbname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.DropdbStmt.dbname)
}
inline std::string* DropdbStmt::mutable_dbname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_dbname();
  // @@protoc_insertion_point(field_mutable:pg_query.DropdbStmt.dbname)
  return _s;
}
inline const std::string& DropdbStmt::_internal_dbname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.dbname_.Get();
}
inline void DropdbStmt::_internal_set_dbname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.dbname_.Set(value, GetArena());
}
inline std::string* DropdbStmt::_internal_mutable_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.dbname_.Mutable( GetArena());
}
inline std::string* DropdbStmt::release_dbname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DropdbStmt.dbname)
  return _impl_.dbname_.Release();
}
inline void DropdbStmt::set_allocated_dbname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.dbname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.dbname_.IsDefault()) {
          _impl_.dbname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.DropdbStmt.dbname)
}

// bool missing_ok = 2 [json_name = "missing_ok"];
inline void DropdbStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool DropdbStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.DropdbStmt.missing_ok)
  return _internal_missing_ok();
}
inline void DropdbStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.DropdbStmt.missing_ok)
}
inline bool DropdbStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void DropdbStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// repeated .pg_query.Node options = 3 [json_name = "options"];
inline int DropdbStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int DropdbStmt::options_size() const {
  return _internal_options_size();
}
inline void DropdbStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* DropdbStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.DropdbStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* DropdbStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DropdbStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& DropdbStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DropdbStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* DropdbStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.DropdbStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& DropdbStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.DropdbStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
DropdbStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
DropdbStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// AlterSystemStmt

// .pg_query.VariableSetStmt setstmt = 1 [json_name = "setstmt"];
inline bool AlterSystemStmt::has_setstmt() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.setstmt_ != nullptr);
  return value;
}
inline void AlterSystemStmt::clear_setstmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.setstmt_ != nullptr) _impl_.setstmt_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::VariableSetStmt& AlterSystemStmt::_internal_setstmt() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::VariableSetStmt* p = _impl_.setstmt_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::VariableSetStmt&>(::pg_query::_VariableSetStmt_default_instance_);
}
inline const ::pg_query::VariableSetStmt& AlterSystemStmt::setstmt() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterSystemStmt.setstmt)
  return _internal_setstmt();
}
inline void AlterSystemStmt::unsafe_arena_set_allocated_setstmt(::pg_query::VariableSetStmt* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.setstmt_);
  }
  _impl_.setstmt_ = reinterpret_cast<::pg_query::VariableSetStmt*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterSystemStmt.setstmt)
}
inline ::pg_query::VariableSetStmt* AlterSystemStmt::release_setstmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::VariableSetStmt* released = _impl_.setstmt_;
  _impl_.setstmt_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::VariableSetStmt* AlterSystemStmt::unsafe_arena_release_setstmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterSystemStmt.setstmt)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::VariableSetStmt* temp = _impl_.setstmt_;
  _impl_.setstmt_ = nullptr;
  return temp;
}
inline ::pg_query::VariableSetStmt* AlterSystemStmt::_internal_mutable_setstmt() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.setstmt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::VariableSetStmt>(GetArena());
    _impl_.setstmt_ = reinterpret_cast<::pg_query::VariableSetStmt*>(p);
  }
  return _impl_.setstmt_;
}
inline ::pg_query::VariableSetStmt* AlterSystemStmt::mutable_setstmt() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::VariableSetStmt* _msg = _internal_mutable_setstmt();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSystemStmt.setstmt)
  return _msg;
}
inline void AlterSystemStmt::set_allocated_setstmt(::pg_query::VariableSetStmt* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::VariableSetStmt*>(_impl_.setstmt_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::VariableSetStmt*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.setstmt_ = reinterpret_cast<::pg_query::VariableSetStmt*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterSystemStmt.setstmt)
}

// -------------------------------------------------------------------

// ClusterStmt

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool ClusterStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void ClusterStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& ClusterStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& ClusterStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ClusterStmt.relation)
  return _internal_relation();
}
inline void ClusterStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ClusterStmt.relation)
}
inline ::pg_query::RangeVar* ClusterStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* ClusterStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ClusterStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* ClusterStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* ClusterStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.ClusterStmt.relation)
  return _msg;
}
inline void ClusterStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ClusterStmt.relation)
}

// string indexname = 2 [json_name = "indexname"];
inline void ClusterStmt::clear_indexname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indexname_.ClearToEmpty();
}
inline const std::string& ClusterStmt::indexname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ClusterStmt.indexname)
  return _internal_indexname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ClusterStmt::set_indexname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.indexname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ClusterStmt.indexname)
}
inline std::string* ClusterStmt::mutable_indexname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_indexname();
  // @@protoc_insertion_point(field_mutable:pg_query.ClusterStmt.indexname)
  return _s;
}
inline const std::string& ClusterStmt::_internal_indexname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.indexname_.Get();
}
inline void ClusterStmt::_internal_set_indexname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.indexname_.Set(value, GetArena());
}
inline std::string* ClusterStmt::_internal_mutable_indexname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.indexname_.Mutable( GetArena());
}
inline std::string* ClusterStmt::release_indexname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ClusterStmt.indexname)
  return _impl_.indexname_.Release();
}
inline void ClusterStmt::set_allocated_indexname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.indexname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.indexname_.IsDefault()) {
          _impl_.indexname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.ClusterStmt.indexname)
}

// repeated .pg_query.Node params = 3 [json_name = "params"];
inline int ClusterStmt::_internal_params_size() const {
  return _internal_params().size();
}
inline int ClusterStmt::params_size() const {
  return _internal_params_size();
}
inline void ClusterStmt::clear_params() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.params_.Clear();
}
inline ::pg_query::Node* ClusterStmt::mutable_params(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ClusterStmt.params)
  return _internal_mutable_params()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ClusterStmt::mutable_params()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ClusterStmt.params)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_params();
}
inline const ::pg_query::Node& ClusterStmt::params(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ClusterStmt.params)
  return _internal_params().Get(index);
}
inline ::pg_query::Node* ClusterStmt::add_params() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_params()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ClusterStmt.params)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ClusterStmt::params() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ClusterStmt.params)
  return _internal_params();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ClusterStmt::_internal_params() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.params_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ClusterStmt::_internal_mutable_params() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.params_;
}

// -------------------------------------------------------------------

// VacuumStmt

// repeated .pg_query.Node options = 1 [json_name = "options"];
inline int VacuumStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int VacuumStmt::options_size() const {
  return _internal_options_size();
}
inline void VacuumStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* VacuumStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.VacuumStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* VacuumStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.VacuumStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& VacuumStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.VacuumStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* VacuumStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.VacuumStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& VacuumStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.VacuumStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
VacuumStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
VacuumStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// repeated .pg_query.Node rels = 2 [json_name = "rels"];
inline int VacuumStmt::_internal_rels_size() const {
  return _internal_rels().size();
}
inline int VacuumStmt::rels_size() const {
  return _internal_rels_size();
}
inline void VacuumStmt::clear_rels() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.rels_.Clear();
}
inline ::pg_query::Node* VacuumStmt::mutable_rels(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.VacuumStmt.rels)
  return _internal_mutable_rels()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* VacuumStmt::mutable_rels()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.VacuumStmt.rels)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_rels();
}
inline const ::pg_query::Node& VacuumStmt::rels(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.VacuumStmt.rels)
  return _internal_rels().Get(index);
}
inline ::pg_query::Node* VacuumStmt::add_rels() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_rels()->Add();
  // @@protoc_insertion_point(field_add:pg_query.VacuumStmt.rels)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& VacuumStmt::rels() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.VacuumStmt.rels)
  return _internal_rels();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
VacuumStmt::_internal_rels() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.rels_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
VacuumStmt::_internal_mutable_rels() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.rels_;
}

// bool is_vacuumcmd = 3 [json_name = "is_vacuumcmd"];
inline void VacuumStmt::clear_is_vacuumcmd() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_vacuumcmd_ = false;
}
inline bool VacuumStmt::is_vacuumcmd() const {
  // @@protoc_insertion_point(field_get:pg_query.VacuumStmt.is_vacuumcmd)
  return _internal_is_vacuumcmd();
}
inline void VacuumStmt::set_is_vacuumcmd(bool value) {
  _internal_set_is_vacuumcmd(value);
  // @@protoc_insertion_point(field_set:pg_query.VacuumStmt.is_vacuumcmd)
}
inline bool VacuumStmt::_internal_is_vacuumcmd() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_vacuumcmd_;
}
inline void VacuumStmt::_internal_set_is_vacuumcmd(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_vacuumcmd_ = value;
}

// -------------------------------------------------------------------

// VacuumRelation

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool VacuumRelation::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void VacuumRelation::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& VacuumRelation::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& VacuumRelation::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.VacuumRelation.relation)
  return _internal_relation();
}
inline void VacuumRelation::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.VacuumRelation.relation)
}
inline ::pg_query::RangeVar* VacuumRelation::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* VacuumRelation::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.VacuumRelation.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* VacuumRelation::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* VacuumRelation::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.VacuumRelation.relation)
  return _msg;
}
inline void VacuumRelation::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.VacuumRelation.relation)
}

// uint32 oid = 2 [json_name = "oid"];
inline void VacuumRelation::clear_oid() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.oid_ = 0u;
}
inline ::uint32_t VacuumRelation::oid() const {
  // @@protoc_insertion_point(field_get:pg_query.VacuumRelation.oid)
  return _internal_oid();
}
inline void VacuumRelation::set_oid(::uint32_t value) {
  _internal_set_oid(value);
  // @@protoc_insertion_point(field_set:pg_query.VacuumRelation.oid)
}
inline ::uint32_t VacuumRelation::_internal_oid() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.oid_;
}
inline void VacuumRelation::_internal_set_oid(::uint32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.oid_ = value;
}

// repeated .pg_query.Node va_cols = 3 [json_name = "va_cols"];
inline int VacuumRelation::_internal_va_cols_size() const {
  return _internal_va_cols().size();
}
inline int VacuumRelation::va_cols_size() const {
  return _internal_va_cols_size();
}
inline void VacuumRelation::clear_va_cols() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.va_cols_.Clear();
}
inline ::pg_query::Node* VacuumRelation::mutable_va_cols(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.VacuumRelation.va_cols)
  return _internal_mutable_va_cols()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* VacuumRelation::mutable_va_cols()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.VacuumRelation.va_cols)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_va_cols();
}
inline const ::pg_query::Node& VacuumRelation::va_cols(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.VacuumRelation.va_cols)
  return _internal_va_cols().Get(index);
}
inline ::pg_query::Node* VacuumRelation::add_va_cols() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_va_cols()->Add();
  // @@protoc_insertion_point(field_add:pg_query.VacuumRelation.va_cols)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& VacuumRelation::va_cols() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.VacuumRelation.va_cols)
  return _internal_va_cols();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
VacuumRelation::_internal_va_cols() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.va_cols_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
VacuumRelation::_internal_mutable_va_cols() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.va_cols_;
}

// -------------------------------------------------------------------

// ExplainStmt

// .pg_query.Node query = 1 [json_name = "query"];
inline bool ExplainStmt::has_query() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.query_ != nullptr);
  return value;
}
inline void ExplainStmt::clear_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.query_ != nullptr) _impl_.query_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& ExplainStmt::_internal_query() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& ExplainStmt::query() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ExplainStmt.query)
  return _internal_query();
}
inline void ExplainStmt::unsafe_arena_set_allocated_query(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.query_);
  }
  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ExplainStmt.query)
}
inline ::pg_query::Node* ExplainStmt::release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.query_;
  _impl_.query_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* ExplainStmt::unsafe_arena_release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ExplainStmt.query)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.query_;
  _impl_.query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* ExplainStmt::_internal_mutable_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.query_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.query_;
}
inline ::pg_query::Node* ExplainStmt::mutable_query() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_query();
  // @@protoc_insertion_point(field_mutable:pg_query.ExplainStmt.query)
  return _msg;
}
inline void ExplainStmt::set_allocated_query(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.query_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@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 _internal_options().size();
}
inline int ExplainStmt::options_size() const {
  return _internal_options_size();
}
inline void ExplainStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* ExplainStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ExplainStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ExplainStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ExplainStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& ExplainStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ExplainStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* ExplainStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ExplainStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ExplainStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ExplainStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ExplainStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ExplainStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// CreateTableAsStmt

// .pg_query.Node query = 1 [json_name = "query"];
inline bool CreateTableAsStmt::has_query() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.query_ != nullptr);
  return value;
}
inline void CreateTableAsStmt::clear_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.query_ != nullptr) _impl_.query_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& CreateTableAsStmt::_internal_query() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& CreateTableAsStmt::query() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.query)
  return _internal_query();
}
inline void CreateTableAsStmt::unsafe_arena_set_allocated_query(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.query_);
  }
  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTableAsStmt.query)
}
inline ::pg_query::Node* CreateTableAsStmt::release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.query_;
  _impl_.query_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* CreateTableAsStmt::unsafe_arena_release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTableAsStmt.query)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.query_;
  _impl_.query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* CreateTableAsStmt::_internal_mutable_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.query_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.query_;
}
inline ::pg_query::Node* CreateTableAsStmt::mutable_query() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_query();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTableAsStmt.query)
  return _msg;
}
inline void CreateTableAsStmt::set_allocated_query(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.query_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTableAsStmt.query)
}

// .pg_query.IntoClause into = 2 [json_name = "into"];
inline bool CreateTableAsStmt::has_into() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.into_ != nullptr);
  return value;
}
inline void CreateTableAsStmt::clear_into() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.into_ != nullptr) _impl_.into_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::IntoClause& CreateTableAsStmt::_internal_into() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::IntoClause* p = _impl_.into_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::IntoClause&>(::pg_query::_IntoClause_default_instance_);
}
inline const ::pg_query::IntoClause& CreateTableAsStmt::into() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.into)
  return _internal_into();
}
inline void CreateTableAsStmt::unsafe_arena_set_allocated_into(::pg_query::IntoClause* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.into_);
  }
  _impl_.into_ = reinterpret_cast<::pg_query::IntoClause*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTableAsStmt.into)
}
inline ::pg_query::IntoClause* CreateTableAsStmt::release_into() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::IntoClause* released = _impl_.into_;
  _impl_.into_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::IntoClause* CreateTableAsStmt::unsafe_arena_release_into() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTableAsStmt.into)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::IntoClause* temp = _impl_.into_;
  _impl_.into_ = nullptr;
  return temp;
}
inline ::pg_query::IntoClause* CreateTableAsStmt::_internal_mutable_into() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.into_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::IntoClause>(GetArena());
    _impl_.into_ = reinterpret_cast<::pg_query::IntoClause*>(p);
  }
  return _impl_.into_;
}
inline ::pg_query::IntoClause* CreateTableAsStmt::mutable_into() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::IntoClause* _msg = _internal_mutable_into();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTableAsStmt.into)
  return _msg;
}
inline void CreateTableAsStmt::set_allocated_into(::pg_query::IntoClause* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::IntoClause*>(_impl_.into_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::IntoClause*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.into_ = reinterpret_cast<::pg_query::IntoClause*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTableAsStmt.into)
}

// .pg_query.ObjectType objtype = 3 [json_name = "objtype"];
inline void CreateTableAsStmt::clear_objtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.objtype_ = 0;
}
inline ::pg_query::ObjectType CreateTableAsStmt::objtype() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.objtype)
  return _internal_objtype();
}
inline void CreateTableAsStmt::set_objtype(::pg_query::ObjectType value) {
  _internal_set_objtype(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTableAsStmt.objtype)
}
inline ::pg_query::ObjectType CreateTableAsStmt::_internal_objtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ObjectType>(_impl_.objtype_);
}
inline void CreateTableAsStmt::_internal_set_objtype(::pg_query::ObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.objtype_ = value;
}

// bool is_select_into = 4 [json_name = "is_select_into"];
inline void CreateTableAsStmt::clear_is_select_into() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.is_select_into_ = false;
}
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::set_is_select_into(bool value) {
  _internal_set_is_select_into(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTableAsStmt.is_select_into)
}
inline bool CreateTableAsStmt::_internal_is_select_into() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.is_select_into_;
}
inline void CreateTableAsStmt::_internal_set_is_select_into(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.is_select_into_ = value;
}

// bool if_not_exists = 5 [json_name = "if_not_exists"];
inline void CreateTableAsStmt::clear_if_not_exists() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.if_not_exists_ = false;
}
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::set_if_not_exists(bool value) {
  _internal_set_if_not_exists(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTableAsStmt.if_not_exists)
}
inline bool CreateTableAsStmt::_internal_if_not_exists() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.if_not_exists_;
}
inline void CreateTableAsStmt::_internal_set_if_not_exists(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.if_not_exists_ = value;
}

// -------------------------------------------------------------------

// RefreshMatViewStmt

// bool concurrent = 1 [json_name = "concurrent"];
inline void RefreshMatViewStmt::clear_concurrent() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.concurrent_ = false;
}
inline bool RefreshMatViewStmt::concurrent() const {
  // @@protoc_insertion_point(field_get:pg_query.RefreshMatViewStmt.concurrent)
  return _internal_concurrent();
}
inline void RefreshMatViewStmt::set_concurrent(bool value) {
  _internal_set_concurrent(value);
  // @@protoc_insertion_point(field_set:pg_query.RefreshMatViewStmt.concurrent)
}
inline bool RefreshMatViewStmt::_internal_concurrent() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.concurrent_;
}
inline void RefreshMatViewStmt::_internal_set_concurrent(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.concurrent_ = value;
}

// bool skip_data = 2 [json_name = "skipData"];
inline void RefreshMatViewStmt::clear_skip_data() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.skip_data_ = false;
}
inline bool RefreshMatViewStmt::skip_data() const {
  // @@protoc_insertion_point(field_get:pg_query.RefreshMatViewStmt.skip_data)
  return _internal_skip_data();
}
inline void RefreshMatViewStmt::set_skip_data(bool value) {
  _internal_set_skip_data(value);
  // @@protoc_insertion_point(field_set:pg_query.RefreshMatViewStmt.skip_data)
}
inline bool RefreshMatViewStmt::_internal_skip_data() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.skip_data_;
}
inline void RefreshMatViewStmt::_internal_set_skip_data(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.skip_data_ = value;
}

// .pg_query.RangeVar relation = 3 [json_name = "relation"];
inline bool RefreshMatViewStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void RefreshMatViewStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& RefreshMatViewStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& RefreshMatViewStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.RefreshMatViewStmt.relation)
  return _internal_relation();
}
inline void RefreshMatViewStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RefreshMatViewStmt.relation)
}
inline ::pg_query::RangeVar* RefreshMatViewStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* RefreshMatViewStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.RefreshMatViewStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* RefreshMatViewStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* RefreshMatViewStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.RefreshMatViewStmt.relation)
  return _msg;
}
inline void RefreshMatViewStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.RefreshMatViewStmt.relation)
}

// -------------------------------------------------------------------

// CheckPointStmt

// -------------------------------------------------------------------

// DiscardStmt

// .pg_query.DiscardMode target = 1 [json_name = "target"];
inline void DiscardStmt::clear_target() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.target_ = 0;
}
inline ::pg_query::DiscardMode DiscardStmt::target() const {
  // @@protoc_insertion_point(field_get:pg_query.DiscardStmt.target)
  return _internal_target();
}
inline void DiscardStmt::set_target(::pg_query::DiscardMode value) {
  _internal_set_target(value);
  // @@protoc_insertion_point(field_set:pg_query.DiscardStmt.target)
}
inline ::pg_query::DiscardMode DiscardStmt::_internal_target() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::DiscardMode>(_impl_.target_);
}
inline void DiscardStmt::_internal_set_target(::pg_query::DiscardMode value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.target_ = value;
}

// -------------------------------------------------------------------

// LockStmt

// repeated .pg_query.Node relations = 1 [json_name = "relations"];
inline int LockStmt::_internal_relations_size() const {
  return _internal_relations().size();
}
inline int LockStmt::relations_size() const {
  return _internal_relations_size();
}
inline void LockStmt::clear_relations() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.relations_.Clear();
}
inline ::pg_query::Node* LockStmt::mutable_relations(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.LockStmt.relations)
  return _internal_mutable_relations()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* LockStmt::mutable_relations()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.LockStmt.relations)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_relations();
}
inline const ::pg_query::Node& LockStmt::relations(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.LockStmt.relations)
  return _internal_relations().Get(index);
}
inline ::pg_query::Node* LockStmt::add_relations() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_relations()->Add();
  // @@protoc_insertion_point(field_add:pg_query.LockStmt.relations)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& LockStmt::relations() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.LockStmt.relations)
  return _internal_relations();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
LockStmt::_internal_relations() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.relations_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
LockStmt::_internal_mutable_relations() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.relations_;
}

// int32 mode = 2 [json_name = "mode"];
inline void LockStmt::clear_mode() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.mode_ = 0;
}
inline ::int32_t LockStmt::mode() const {
  // @@protoc_insertion_point(field_get:pg_query.LockStmt.mode)
  return _internal_mode();
}
inline void LockStmt::set_mode(::int32_t value) {
  _internal_set_mode(value);
  // @@protoc_insertion_point(field_set:pg_query.LockStmt.mode)
}
inline ::int32_t LockStmt::_internal_mode() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.mode_;
}
inline void LockStmt::_internal_set_mode(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.mode_ = value;
}

// bool nowait = 3 [json_name = "nowait"];
inline void LockStmt::clear_nowait() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.nowait_ = false;
}
inline bool LockStmt::nowait() const {
  // @@protoc_insertion_point(field_get:pg_query.LockStmt.nowait)
  return _internal_nowait();
}
inline void LockStmt::set_nowait(bool value) {
  _internal_set_nowait(value);
  // @@protoc_insertion_point(field_set:pg_query.LockStmt.nowait)
}
inline bool LockStmt::_internal_nowait() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.nowait_;
}
inline void LockStmt::_internal_set_nowait(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.nowait_ = value;
}

// -------------------------------------------------------------------

// ConstraintsSetStmt

// repeated .pg_query.Node constraints = 1 [json_name = "constraints"];
inline int ConstraintsSetStmt::_internal_constraints_size() const {
  return _internal_constraints().size();
}
inline int ConstraintsSetStmt::constraints_size() const {
  return _internal_constraints_size();
}
inline void ConstraintsSetStmt::clear_constraints() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.constraints_.Clear();
}
inline ::pg_query::Node* ConstraintsSetStmt::mutable_constraints(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ConstraintsSetStmt.constraints)
  return _internal_mutable_constraints()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ConstraintsSetStmt::mutable_constraints()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ConstraintsSetStmt.constraints)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_constraints();
}
inline const ::pg_query::Node& ConstraintsSetStmt::constraints(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ConstraintsSetStmt.constraints)
  return _internal_constraints().Get(index);
}
inline ::pg_query::Node* ConstraintsSetStmt::add_constraints() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_constraints()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ConstraintsSetStmt.constraints)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ConstraintsSetStmt::constraints() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ConstraintsSetStmt.constraints)
  return _internal_constraints();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ConstraintsSetStmt::_internal_constraints() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.constraints_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ConstraintsSetStmt::_internal_mutable_constraints() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.constraints_;
}

// bool deferred = 2 [json_name = "deferred"];
inline void ConstraintsSetStmt::clear_deferred() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.deferred_ = false;
}
inline bool ConstraintsSetStmt::deferred() const {
  // @@protoc_insertion_point(field_get:pg_query.ConstraintsSetStmt.deferred)
  return _internal_deferred();
}
inline void ConstraintsSetStmt::set_deferred(bool value) {
  _internal_set_deferred(value);
  // @@protoc_insertion_point(field_set:pg_query.ConstraintsSetStmt.deferred)
}
inline bool ConstraintsSetStmt::_internal_deferred() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.deferred_;
}
inline void ConstraintsSetStmt::_internal_set_deferred(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.deferred_ = value;
}

// -------------------------------------------------------------------

// ReindexStmt

// .pg_query.ReindexObjectType kind = 1 [json_name = "kind"];
inline void ReindexStmt::clear_kind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.kind_ = 0;
}
inline ::pg_query::ReindexObjectType ReindexStmt::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.kind)
  return _internal_kind();
}
inline void ReindexStmt::set_kind(::pg_query::ReindexObjectType value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.ReindexStmt.kind)
}
inline ::pg_query::ReindexObjectType ReindexStmt::_internal_kind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::ReindexObjectType>(_impl_.kind_);
}
inline void ReindexStmt::_internal_set_kind(::pg_query::ReindexObjectType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.kind_ = value;
}

// .pg_query.RangeVar relation = 2 [json_name = "relation"];
inline bool ReindexStmt::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void ReindexStmt::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& ReindexStmt::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& ReindexStmt::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.relation)
  return _internal_relation();
}
inline void ReindexStmt::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ReindexStmt.relation)
}
inline ::pg_query::RangeVar* ReindexStmt::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* ReindexStmt::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ReindexStmt.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* ReindexStmt::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* ReindexStmt::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.ReindexStmt.relation)
  return _msg;
}
inline void ReindexStmt::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ReindexStmt.relation)
}

// string name = 3 [json_name = "name"];
inline void ReindexStmt::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& ReindexStmt::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ReindexStmt::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ReindexStmt.name)
}
inline std::string* ReindexStmt::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.ReindexStmt.name)
  return _s;
}
inline const std::string& ReindexStmt::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void ReindexStmt::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* ReindexStmt::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* ReindexStmt::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ReindexStmt.name)
  return _impl_.name_.Release();
}
inline void ReindexStmt::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.ReindexStmt.name)
}

// repeated .pg_query.Node params = 4 [json_name = "params"];
inline int ReindexStmt::_internal_params_size() const {
  return _internal_params().size();
}
inline int ReindexStmt::params_size() const {
  return _internal_params_size();
}
inline void ReindexStmt::clear_params() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.params_.Clear();
}
inline ::pg_query::Node* ReindexStmt::mutable_params(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ReindexStmt.params)
  return _internal_mutable_params()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ReindexStmt::mutable_params()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ReindexStmt.params)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_params();
}
inline const ::pg_query::Node& ReindexStmt::params(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.params)
  return _internal_params().Get(index);
}
inline ::pg_query::Node* ReindexStmt::add_params() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_params()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ReindexStmt.params)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ReindexStmt::params() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ReindexStmt.params)
  return _internal_params();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ReindexStmt::_internal_params() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.params_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ReindexStmt::_internal_mutable_params() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.params_;
}

// -------------------------------------------------------------------

// CreateConversionStmt

// repeated .pg_query.Node conversion_name = 1 [json_name = "conversion_name"];
inline int CreateConversionStmt::_internal_conversion_name_size() const {
  return _internal_conversion_name().size();
}
inline int CreateConversionStmt::conversion_name_size() const {
  return _internal_conversion_name_size();
}
inline void CreateConversionStmt::clear_conversion_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conversion_name_.Clear();
}
inline ::pg_query::Node* CreateConversionStmt::mutable_conversion_name(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateConversionStmt.conversion_name)
  return _internal_mutable_conversion_name()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateConversionStmt::mutable_conversion_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateConversionStmt.conversion_name)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_conversion_name();
}
inline const ::pg_query::Node& CreateConversionStmt::conversion_name(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.conversion_name)
  return _internal_conversion_name().Get(index);
}
inline ::pg_query::Node* CreateConversionStmt::add_conversion_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_conversion_name()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateConversionStmt.conversion_name)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateConversionStmt::conversion_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateConversionStmt.conversion_name)
  return _internal_conversion_name();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateConversionStmt::_internal_conversion_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.conversion_name_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateConversionStmt::_internal_mutable_conversion_name() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.conversion_name_;
}

// string for_encoding_name = 2 [json_name = "for_encoding_name"];
inline void CreateConversionStmt::clear_for_encoding_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.for_encoding_name_.ClearToEmpty();
}
inline const std::string& CreateConversionStmt::for_encoding_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.for_encoding_name)
  return _internal_for_encoding_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateConversionStmt::set_for_encoding_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.for_encoding_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateConversionStmt.for_encoding_name)
}
inline std::string* CreateConversionStmt::mutable_for_encoding_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_for_encoding_name();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateConversionStmt.for_encoding_name)
  return _s;
}
inline const std::string& CreateConversionStmt::_internal_for_encoding_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.for_encoding_name_.Get();
}
inline void CreateConversionStmt::_internal_set_for_encoding_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.for_encoding_name_.Set(value, GetArena());
}
inline std::string* CreateConversionStmt::_internal_mutable_for_encoding_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.for_encoding_name_.Mutable( GetArena());
}
inline std::string* CreateConversionStmt::release_for_encoding_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateConversionStmt.for_encoding_name)
  return _impl_.for_encoding_name_.Release();
}
inline void CreateConversionStmt::set_allocated_for_encoding_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.for_encoding_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.for_encoding_name_.IsDefault()) {
          _impl_.for_encoding_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.to_encoding_name_.ClearToEmpty();
}
inline const std::string& CreateConversionStmt::to_encoding_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.to_encoding_name)
  return _internal_to_encoding_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateConversionStmt::set_to_encoding_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.to_encoding_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateConversionStmt.to_encoding_name)
}
inline std::string* CreateConversionStmt::mutable_to_encoding_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_to_encoding_name();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateConversionStmt.to_encoding_name)
  return _s;
}
inline const std::string& CreateConversionStmt::_internal_to_encoding_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.to_encoding_name_.Get();
}
inline void CreateConversionStmt::_internal_set_to_encoding_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.to_encoding_name_.Set(value, GetArena());
}
inline std::string* CreateConversionStmt::_internal_mutable_to_encoding_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.to_encoding_name_.Mutable( GetArena());
}
inline std::string* CreateConversionStmt::release_to_encoding_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateConversionStmt.to_encoding_name)
  return _impl_.to_encoding_name_.Release();
}
inline void CreateConversionStmt::set_allocated_to_encoding_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.to_encoding_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.to_encoding_name_.IsDefault()) {
          _impl_.to_encoding_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_func_name().size();
}
inline int CreateConversionStmt::func_name_size() const {
  return _internal_func_name_size();
}
inline void CreateConversionStmt::clear_func_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.func_name_.Clear();
}
inline ::pg_query::Node* CreateConversionStmt::mutable_func_name(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateConversionStmt.func_name)
  return _internal_mutable_func_name()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateConversionStmt::mutable_func_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateConversionStmt.func_name)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_func_name();
}
inline const ::pg_query::Node& CreateConversionStmt::func_name(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.func_name)
  return _internal_func_name().Get(index);
}
inline ::pg_query::Node* CreateConversionStmt::add_func_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_func_name()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateConversionStmt.func_name)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateConversionStmt::func_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateConversionStmt.func_name)
  return _internal_func_name();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateConversionStmt::_internal_func_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.func_name_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateConversionStmt::_internal_mutable_func_name() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.func_name_;
}

// bool def = 5 [json_name = "def"];
inline void CreateConversionStmt::clear_def() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.def_ = false;
}
inline bool CreateConversionStmt::def() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.def)
  return _internal_def();
}
inline void CreateConversionStmt::set_def(bool value) {
  _internal_set_def(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateConversionStmt.def)
}
inline bool CreateConversionStmt::_internal_def() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.def_;
}
inline void CreateConversionStmt::_internal_set_def(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.def_ = value;
}

// -------------------------------------------------------------------

// CreateCastStmt

// .pg_query.TypeName sourcetype = 1 [json_name = "sourcetype"];
inline bool CreateCastStmt::has_sourcetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sourcetype_ != nullptr);
  return value;
}
inline void CreateCastStmt::clear_sourcetype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.sourcetype_ != nullptr) _impl_.sourcetype_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::TypeName& CreateCastStmt::_internal_sourcetype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.sourcetype_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& CreateCastStmt::sourcetype() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.sourcetype)
  return _internal_sourcetype();
}
inline void CreateCastStmt::unsafe_arena_set_allocated_sourcetype(::pg_query::TypeName* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcetype_);
  }
  _impl_.sourcetype_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateCastStmt.sourcetype)
}
inline ::pg_query::TypeName* CreateCastStmt::release_sourcetype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* released = _impl_.sourcetype_;
  _impl_.sourcetype_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* CreateCastStmt::unsafe_arena_release_sourcetype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateCastStmt.sourcetype)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* temp = _impl_.sourcetype_;
  _impl_.sourcetype_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateCastStmt::_internal_mutable_sourcetype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.sourcetype_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.sourcetype_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.sourcetype_;
}
inline ::pg_query::TypeName* CreateCastStmt::mutable_sourcetype() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_sourcetype();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateCastStmt.sourcetype)
  return _msg;
}
inline void CreateCastStmt::set_allocated_sourcetype(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.sourcetype_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.sourcetype_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateCastStmt.sourcetype)
}

// .pg_query.TypeName targettype = 2 [json_name = "targettype"];
inline bool CreateCastStmt::has_targettype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.targettype_ != nullptr);
  return value;
}
inline void CreateCastStmt::clear_targettype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.targettype_ != nullptr) _impl_.targettype_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::TypeName& CreateCastStmt::_internal_targettype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.targettype_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::TypeName&>(::pg_query::_TypeName_default_instance_);
}
inline const ::pg_query::TypeName& CreateCastStmt::targettype() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.targettype)
  return _internal_targettype();
}
inline void CreateCastStmt::unsafe_arena_set_allocated_targettype(::pg_query::TypeName* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.targettype_);
  }
  _impl_.targettype_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateCastStmt.targettype)
}
inline ::pg_query::TypeName* CreateCastStmt::release_targettype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::TypeName* released = _impl_.targettype_;
  _impl_.targettype_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* CreateCastStmt::unsafe_arena_release_targettype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateCastStmt.targettype)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::TypeName* temp = _impl_.targettype_;
  _impl_.targettype_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateCastStmt::_internal_mutable_targettype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.targettype_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.targettype_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.targettype_;
}
inline ::pg_query::TypeName* CreateCastStmt::mutable_targettype() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_targettype();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateCastStmt.targettype)
  return _msg;
}
inline void CreateCastStmt::set_allocated_targettype(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.targettype_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.targettype_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateCastStmt.targettype)
}

// .pg_query.ObjectWithArgs func = 3 [json_name = "func"];
inline bool CreateCastStmt::has_func() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.func_ != nullptr);
  return value;
}
inline void CreateCastStmt::clear_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.func_ != nullptr) _impl_.func_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::ObjectWithArgs& CreateCastStmt::_internal_func() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::ObjectWithArgs* p = _impl_.func_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::ObjectWithArgs&>(::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& CreateCastStmt::func() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.func)
  return _internal_func();
}
inline void CreateCastStmt::unsafe_arena_set_allocated_func(::pg_query::ObjectWithArgs* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.func_);
  }
  _impl_.func_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateCastStmt.func)
}
inline ::pg_query::ObjectWithArgs* CreateCastStmt::release_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::ObjectWithArgs* released = _impl_.func_;
  _impl_.func_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::ObjectWithArgs* CreateCastStmt::unsafe_arena_release_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateCastStmt.func)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::ObjectWithArgs* temp = _impl_.func_;
  _impl_.func_ = nullptr;
  return temp;
}
inline ::pg_query::ObjectWithArgs* CreateCastStmt::_internal_mutable_func() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.func_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
    _impl_.func_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(p);
  }
  return _impl_.func_;
}
inline ::pg_query::ObjectWithArgs* CreateCastStmt::mutable_func() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ObjectWithArgs* _msg = _internal_mutable_func();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateCastStmt.func)
  return _msg;
}
inline void CreateCastStmt::set_allocated_func(::pg_query::ObjectWithArgs* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::ObjectWithArgs*>(_impl_.func_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::ObjectWithArgs*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.func_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateCastStmt.func)
}

// .pg_query.CoercionContext context = 4 [json_name = "context"];
inline void CreateCastStmt::clear_context() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.context_ = 0;
}
inline ::pg_query::CoercionContext CreateCastStmt::context() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.context)
  return _internal_context();
}
inline void CreateCastStmt::set_context(::pg_query::CoercionContext value) {
  _internal_set_context(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateCastStmt.context)
}
inline ::pg_query::CoercionContext CreateCastStmt::_internal_context() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::CoercionContext>(_impl_.context_);
}
inline void CreateCastStmt::_internal_set_context(::pg_query::CoercionContext value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.context_ = value;
}

// bool inout = 5 [json_name = "inout"];
inline void CreateCastStmt::clear_inout() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.inout_ = false;
}
inline bool CreateCastStmt::inout() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.inout)
  return _internal_inout();
}
inline void CreateCastStmt::set_inout(bool value) {
  _internal_set_inout(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateCastStmt.inout)
}
inline bool CreateCastStmt::_internal_inout() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.inout_;
}
inline void CreateCastStmt::_internal_set_inout(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.inout_ = value;
}

// -------------------------------------------------------------------

// CreateTransformStmt

// bool replace = 1 [json_name = "replace"];
inline void CreateTransformStmt::clear_replace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.replace_ = false;
}
inline bool CreateTransformStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.replace)
  return _internal_replace();
}
inline void CreateTransformStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.CreateTransformStmt.replace)
}
inline bool CreateTransformStmt::_internal_replace() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.replace_;
}
inline void CreateTransformStmt::_internal_set_replace(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.replace_ = value;
}

// .pg_query.TypeName type_name = 2 [json_name = "type_name"];
inline bool CreateTransformStmt::has_type_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.type_name_ != nullptr);
  return value;
}
inline void CreateTransformStmt::clear_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.type_name_ != nullptr) _impl_.type_name_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::TypeName& CreateTransformStmt::_internal_type_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::TypeName* p = _impl_.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 ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@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* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.type_name_);
  }
  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTransformStmt.type_name)
}
inline ::pg_query::TypeName* CreateTransformStmt::release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* released = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::TypeName* CreateTransformStmt::unsafe_arena_release_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTransformStmt.type_name)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::TypeName* temp = _impl_.type_name_;
  _impl_.type_name_ = nullptr;
  return temp;
}
inline ::pg_query::TypeName* CreateTransformStmt::_internal_mutable_type_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.type_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArena());
    _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(p);
  }
  return _impl_.type_name_;
}
inline ::pg_query::TypeName* CreateTransformStmt::mutable_type_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::TypeName* _msg = _internal_mutable_type_name();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTransformStmt.type_name)
  return _msg;
}
inline void CreateTransformStmt::set_allocated_type_name(::pg_query::TypeName* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::TypeName*>(_impl_.type_name_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::TypeName*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.type_name_ = reinterpret_cast<::pg_query::TypeName*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTransformStmt.type_name)
}

// string lang = 3 [json_name = "lang"];
inline void CreateTransformStmt::clear_lang() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.lang_.ClearToEmpty();
}
inline const std::string& CreateTransformStmt::lang() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.lang)
  return _internal_lang();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateTransformStmt::set_lang(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.lang_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateTransformStmt.lang)
}
inline std::string* CreateTransformStmt::mutable_lang() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_lang();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTransformStmt.lang)
  return _s;
}
inline const std::string& CreateTransformStmt::_internal_lang() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.lang_.Get();
}
inline void CreateTransformStmt::_internal_set_lang(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.lang_.Set(value, GetArena());
}
inline std::string* CreateTransformStmt::_internal_mutable_lang() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.lang_.Mutable( GetArena());
}
inline std::string* CreateTransformStmt::release_lang() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTransformStmt.lang)
  return _impl_.lang_.Release();
}
inline void CreateTransformStmt::set_allocated_lang(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.lang_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.lang_.IsDefault()) {
          _impl_.lang_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTransformStmt.lang)
}

// .pg_query.ObjectWithArgs fromsql = 4 [json_name = "fromsql"];
inline bool CreateTransformStmt::has_fromsql() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fromsql_ != nullptr);
  return value;
}
inline void CreateTransformStmt::clear_fromsql() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.fromsql_ != nullptr) _impl_.fromsql_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::ObjectWithArgs& CreateTransformStmt::_internal_fromsql() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::ObjectWithArgs* p = _impl_.fromsql_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::ObjectWithArgs&>(::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& CreateTransformStmt::fromsql() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.fromsql)
  return _internal_fromsql();
}
inline void CreateTransformStmt::unsafe_arena_set_allocated_fromsql(::pg_query::ObjectWithArgs* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.fromsql_);
  }
  _impl_.fromsql_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTransformStmt.fromsql)
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::release_fromsql() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::ObjectWithArgs* released = _impl_.fromsql_;
  _impl_.fromsql_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::unsafe_arena_release_fromsql() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTransformStmt.fromsql)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::ObjectWithArgs* temp = _impl_.fromsql_;
  _impl_.fromsql_ = nullptr;
  return temp;
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::_internal_mutable_fromsql() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.fromsql_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
    _impl_.fromsql_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(p);
  }
  return _impl_.fromsql_;
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::mutable_fromsql() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ObjectWithArgs* _msg = _internal_mutable_fromsql();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTransformStmt.fromsql)
  return _msg;
}
inline void CreateTransformStmt::set_allocated_fromsql(::pg_query::ObjectWithArgs* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::ObjectWithArgs*>(_impl_.fromsql_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::ObjectWithArgs*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.fromsql_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTransformStmt.fromsql)
}

// .pg_query.ObjectWithArgs tosql = 5 [json_name = "tosql"];
inline bool CreateTransformStmt::has_tosql() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.tosql_ != nullptr);
  return value;
}
inline void CreateTransformStmt::clear_tosql() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.tosql_ != nullptr) _impl_.tosql_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::pg_query::ObjectWithArgs& CreateTransformStmt::_internal_tosql() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::ObjectWithArgs* p = _impl_.tosql_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::ObjectWithArgs&>(::pg_query::_ObjectWithArgs_default_instance_);
}
inline const ::pg_query::ObjectWithArgs& CreateTransformStmt::tosql() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.tosql)
  return _internal_tosql();
}
inline void CreateTransformStmt::unsafe_arena_set_allocated_tosql(::pg_query::ObjectWithArgs* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tosql_);
  }
  _impl_.tosql_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTransformStmt.tosql)
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::release_tosql() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::ObjectWithArgs* released = _impl_.tosql_;
  _impl_.tosql_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::unsafe_arena_release_tosql() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateTransformStmt.tosql)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::pg_query::ObjectWithArgs* temp = _impl_.tosql_;
  _impl_.tosql_ = nullptr;
  return temp;
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::_internal_mutable_tosql() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.tosql_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArena());
    _impl_.tosql_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(p);
  }
  return _impl_.tosql_;
}
inline ::pg_query::ObjectWithArgs* CreateTransformStmt::mutable_tosql() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::ObjectWithArgs* _msg = _internal_mutable_tosql();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateTransformStmt.tosql)
  return _msg;
}
inline void CreateTransformStmt::set_allocated_tosql(::pg_query::ObjectWithArgs* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::ObjectWithArgs*>(_impl_.tosql_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::ObjectWithArgs*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.tosql_ = reinterpret_cast<::pg_query::ObjectWithArgs*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTransformStmt.tosql)
}

// -------------------------------------------------------------------

// PrepareStmt

// string name = 1 [json_name = "name"];
inline void PrepareStmt::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& PrepareStmt::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PrepareStmt.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void PrepareStmt::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.PrepareStmt.name)
}
inline std::string* PrepareStmt::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.PrepareStmt.name)
  return _s;
}
inline const std::string& PrepareStmt::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void PrepareStmt::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* PrepareStmt::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* PrepareStmt::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PrepareStmt.name)
  return _impl_.name_.Release();
}
inline void PrepareStmt::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_argtypes().size();
}
inline int PrepareStmt::argtypes_size() const {
  return _internal_argtypes_size();
}
inline void PrepareStmt::clear_argtypes() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.argtypes_.Clear();
}
inline ::pg_query::Node* PrepareStmt::mutable_argtypes(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.PrepareStmt.argtypes)
  return _internal_mutable_argtypes()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* PrepareStmt::mutable_argtypes()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PrepareStmt.argtypes)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_argtypes();
}
inline const ::pg_query::Node& PrepareStmt::argtypes(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PrepareStmt.argtypes)
  return _internal_argtypes().Get(index);
}
inline ::pg_query::Node* PrepareStmt::add_argtypes() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_argtypes()->Add();
  // @@protoc_insertion_point(field_add:pg_query.PrepareStmt.argtypes)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& PrepareStmt::argtypes() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.PrepareStmt.argtypes)
  return _internal_argtypes();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
PrepareStmt::_internal_argtypes() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.argtypes_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
PrepareStmt::_internal_mutable_argtypes() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.argtypes_;
}

// .pg_query.Node query = 3 [json_name = "query"];
inline bool PrepareStmt::has_query() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.query_ != nullptr);
  return value;
}
inline void PrepareStmt::clear_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.query_ != nullptr) _impl_.query_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::Node& PrepareStmt::_internal_query() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.query_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& PrepareStmt::query() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PrepareStmt.query)
  return _internal_query();
}
inline void PrepareStmt::unsafe_arena_set_allocated_query(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.query_);
  }
  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PrepareStmt.query)
}
inline ::pg_query::Node* PrepareStmt::release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* released = _impl_.query_;
  _impl_.query_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* PrepareStmt::unsafe_arena_release_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PrepareStmt.query)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::Node* temp = _impl_.query_;
  _impl_.query_ = nullptr;
  return temp;
}
inline ::pg_query::Node* PrepareStmt::_internal_mutable_query() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.query_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.query_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.query_;
}
inline ::pg_query::Node* PrepareStmt::mutable_query() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_query();
  // @@protoc_insertion_point(field_mutable:pg_query.PrepareStmt.query)
  return _msg;
}
inline void PrepareStmt::set_allocated_query(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.query_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.query_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.PrepareStmt.query)
}

// -------------------------------------------------------------------

// ExecuteStmt

// string name = 1 [json_name = "name"];
inline void ExecuteStmt::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& ExecuteStmt::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ExecuteStmt.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ExecuteStmt::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.ExecuteStmt.name)
}
inline std::string* ExecuteStmt::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.ExecuteStmt.name)
  return _s;
}
inline const std::string& ExecuteStmt::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void ExecuteStmt::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* ExecuteStmt::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* ExecuteStmt::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ExecuteStmt.name)
  return _impl_.name_.Release();
}
inline void ExecuteStmt::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_params().size();
}
inline int ExecuteStmt::params_size() const {
  return _internal_params_size();
}
inline void ExecuteStmt::clear_params() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.params_.Clear();
}
inline ::pg_query::Node* ExecuteStmt::mutable_params(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ExecuteStmt.params)
  return _internal_mutable_params()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ExecuteStmt::mutable_params()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ExecuteStmt.params)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_params();
}
inline const ::pg_query::Node& ExecuteStmt::params(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ExecuteStmt.params)
  return _internal_params().Get(index);
}
inline ::pg_query::Node* ExecuteStmt::add_params() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_params()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ExecuteStmt.params)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ExecuteStmt::params() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ExecuteStmt.params)
  return _internal_params();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ExecuteStmt::_internal_params() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.params_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ExecuteStmt::_internal_mutable_params() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.params_;
}

// -------------------------------------------------------------------

// DeallocateStmt

// string name = 1 [json_name = "name"];
inline void DeallocateStmt::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& DeallocateStmt::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DeallocateStmt.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DeallocateStmt::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.DeallocateStmt.name)
}
inline std::string* DeallocateStmt::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.DeallocateStmt.name)
  return _s;
}
inline const std::string& DeallocateStmt::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void DeallocateStmt::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* DeallocateStmt::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* DeallocateStmt::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DeallocateStmt.name)
  return _impl_.name_.Release();
}
inline void DeallocateStmt::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.DeallocateStmt.name)
}

// -------------------------------------------------------------------

// DropOwnedStmt

// repeated .pg_query.Node roles = 1 [json_name = "roles"];
inline int DropOwnedStmt::_internal_roles_size() const {
  return _internal_roles().size();
}
inline int DropOwnedStmt::roles_size() const {
  return _internal_roles_size();
}
inline void DropOwnedStmt::clear_roles() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.roles_.Clear();
}
inline ::pg_query::Node* DropOwnedStmt::mutable_roles(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.DropOwnedStmt.roles)
  return _internal_mutable_roles()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* DropOwnedStmt::mutable_roles()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.DropOwnedStmt.roles)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_roles();
}
inline const ::pg_query::Node& DropOwnedStmt::roles(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DropOwnedStmt.roles)
  return _internal_roles().Get(index);
}
inline ::pg_query::Node* DropOwnedStmt::add_roles() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_roles()->Add();
  // @@protoc_insertion_point(field_add:pg_query.DropOwnedStmt.roles)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& DropOwnedStmt::roles() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.DropOwnedStmt.roles)
  return _internal_roles();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
DropOwnedStmt::_internal_roles() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.roles_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
DropOwnedStmt::_internal_mutable_roles() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.roles_;
}

// .pg_query.DropBehavior behavior = 2 [json_name = "behavior"];
inline void DropOwnedStmt::clear_behavior() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.behavior_ = 0;
}
inline ::pg_query::DropBehavior DropOwnedStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.DropOwnedStmt.behavior)
  return _internal_behavior();
}
inline void DropOwnedStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.DropOwnedStmt.behavior)
}
inline ::pg_query::DropBehavior DropOwnedStmt::_internal_behavior() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::DropBehavior>(_impl_.behavior_);
}
inline void DropOwnedStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.behavior_ = value;
}

// -------------------------------------------------------------------

// ReassignOwnedStmt

// repeated .pg_query.Node roles = 1 [json_name = "roles"];
inline int ReassignOwnedStmt::_internal_roles_size() const {
  return _internal_roles().size();
}
inline int ReassignOwnedStmt::roles_size() const {
  return _internal_roles_size();
}
inline void ReassignOwnedStmt::clear_roles() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.roles_.Clear();
}
inline ::pg_query::Node* ReassignOwnedStmt::mutable_roles(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.ReassignOwnedStmt.roles)
  return _internal_mutable_roles()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* ReassignOwnedStmt::mutable_roles()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.ReassignOwnedStmt.roles)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_roles();
}
inline const ::pg_query::Node& ReassignOwnedStmt::roles(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ReassignOwnedStmt.roles)
  return _internal_roles().Get(index);
}
inline ::pg_query::Node* ReassignOwnedStmt::add_roles() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_roles()->Add();
  // @@protoc_insertion_point(field_add:pg_query.ReassignOwnedStmt.roles)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& ReassignOwnedStmt::roles() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.ReassignOwnedStmt.roles)
  return _internal_roles();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
ReassignOwnedStmt::_internal_roles() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.roles_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
ReassignOwnedStmt::_internal_mutable_roles() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.roles_;
}

// .pg_query.RoleSpec newrole = 2 [json_name = "newrole"];
inline bool ReassignOwnedStmt::has_newrole() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.newrole_ != nullptr);
  return value;
}
inline void ReassignOwnedStmt::clear_newrole() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.newrole_ != nullptr) _impl_.newrole_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RoleSpec& ReassignOwnedStmt::_internal_newrole() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RoleSpec* p = _impl_.newrole_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_);
}
inline const ::pg_query::RoleSpec& ReassignOwnedStmt::newrole() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.ReassignOwnedStmt.newrole)
  return _internal_newrole();
}
inline void ReassignOwnedStmt::unsafe_arena_set_allocated_newrole(::pg_query::RoleSpec* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.newrole_);
  }
  _impl_.newrole_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ReassignOwnedStmt.newrole)
}
inline ::pg_query::RoleSpec* ReassignOwnedStmt::release_newrole() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* released = _impl_.newrole_;
  _impl_.newrole_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RoleSpec* ReassignOwnedStmt::unsafe_arena_release_newrole() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.ReassignOwnedStmt.newrole)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RoleSpec* temp = _impl_.newrole_;
  _impl_.newrole_ = nullptr;
  return temp;
}
inline ::pg_query::RoleSpec* ReassignOwnedStmt::_internal_mutable_newrole() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.newrole_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArena());
    _impl_.newrole_ = reinterpret_cast<::pg_query::RoleSpec*>(p);
  }
  return _impl_.newrole_;
}
inline ::pg_query::RoleSpec* ReassignOwnedStmt::mutable_newrole() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RoleSpec* _msg = _internal_mutable_newrole();
  // @@protoc_insertion_point(field_mutable:pg_query.ReassignOwnedStmt.newrole)
  return _msg;
}
inline void ReassignOwnedStmt::set_allocated_newrole(::pg_query::RoleSpec* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RoleSpec*>(_impl_.newrole_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RoleSpec*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.newrole_ = reinterpret_cast<::pg_query::RoleSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.ReassignOwnedStmt.newrole)
}

// -------------------------------------------------------------------

// AlterTSDictionaryStmt

// repeated .pg_query.Node dictname = 1 [json_name = "dictname"];
inline int AlterTSDictionaryStmt::_internal_dictname_size() const {
  return _internal_dictname().size();
}
inline int AlterTSDictionaryStmt::dictname_size() const {
  return _internal_dictname_size();
}
inline void AlterTSDictionaryStmt::clear_dictname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.dictname_.Clear();
}
inline ::pg_query::Node* AlterTSDictionaryStmt::mutable_dictname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTSDictionaryStmt.dictname)
  return _internal_mutable_dictname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterTSDictionaryStmt::mutable_dictname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSDictionaryStmt.dictname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_dictname();
}
inline const ::pg_query::Node& AlterTSDictionaryStmt::dictname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSDictionaryStmt.dictname)
  return _internal_dictname().Get(index);
}
inline ::pg_query::Node* AlterTSDictionaryStmt::add_dictname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_dictname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterTSDictionaryStmt.dictname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterTSDictionaryStmt::dictname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterTSDictionaryStmt.dictname)
  return _internal_dictname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterTSDictionaryStmt::_internal_dictname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.dictname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterTSDictionaryStmt::_internal_mutable_dictname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.dictname_;
}

// repeated .pg_query.Node options = 2 [json_name = "options"];
inline int AlterTSDictionaryStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int AlterTSDictionaryStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterTSDictionaryStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterTSDictionaryStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTSDictionaryStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterTSDictionaryStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSDictionaryStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterTSDictionaryStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSDictionaryStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterTSDictionaryStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterTSDictionaryStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterTSDictionaryStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterTSDictionaryStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterTSDictionaryStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterTSDictionaryStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// AlterTSConfigurationStmt

// .pg_query.AlterTSConfigType kind = 1 [json_name = "kind"];
inline void AlterTSConfigurationStmt::clear_kind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.kind_ = 0;
}
inline ::pg_query::AlterTSConfigType AlterTSConfigurationStmt::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.kind)
  return _internal_kind();
}
inline void AlterTSConfigurationStmt::set_kind(::pg_query::AlterTSConfigType value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTSConfigurationStmt.kind)
}
inline ::pg_query::AlterTSConfigType AlterTSConfigurationStmt::_internal_kind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::AlterTSConfigType>(_impl_.kind_);
}
inline void AlterTSConfigurationStmt::_internal_set_kind(::pg_query::AlterTSConfigType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.kind_ = value;
}

// repeated .pg_query.Node cfgname = 2 [json_name = "cfgname"];
inline int AlterTSConfigurationStmt::_internal_cfgname_size() const {
  return _internal_cfgname().size();
}
inline int AlterTSConfigurationStmt::cfgname_size() const {
  return _internal_cfgname_size();
}
inline void AlterTSConfigurationStmt::clear_cfgname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cfgname_.Clear();
}
inline ::pg_query::Node* AlterTSConfigurationStmt::mutable_cfgname(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTSConfigurationStmt.cfgname)
  return _internal_mutable_cfgname()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterTSConfigurationStmt::mutable_cfgname()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSConfigurationStmt.cfgname)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_cfgname();
}
inline const ::pg_query::Node& AlterTSConfigurationStmt::cfgname(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.cfgname)
  return _internal_cfgname().Get(index);
}
inline ::pg_query::Node* AlterTSConfigurationStmt::add_cfgname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_cfgname()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterTSConfigurationStmt.cfgname)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterTSConfigurationStmt::cfgname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterTSConfigurationStmt.cfgname)
  return _internal_cfgname();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterTSConfigurationStmt::_internal_cfgname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cfgname_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterTSConfigurationStmt::_internal_mutable_cfgname() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.cfgname_;
}

// repeated .pg_query.Node tokentype = 3 [json_name = "tokentype"];
inline int AlterTSConfigurationStmt::_internal_tokentype_size() const {
  return _internal_tokentype().size();
}
inline int AlterTSConfigurationStmt::tokentype_size() const {
  return _internal_tokentype_size();
}
inline void AlterTSConfigurationStmt::clear_tokentype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.tokentype_.Clear();
}
inline ::pg_query::Node* AlterTSConfigurationStmt::mutable_tokentype(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTSConfigurationStmt.tokentype)
  return _internal_mutable_tokentype()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterTSConfigurationStmt::mutable_tokentype()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSConfigurationStmt.tokentype)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_tokentype();
}
inline const ::pg_query::Node& AlterTSConfigurationStmt::tokentype(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.tokentype)
  return _internal_tokentype().Get(index);
}
inline ::pg_query::Node* AlterTSConfigurationStmt::add_tokentype() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_tokentype()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterTSConfigurationStmt.tokentype)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterTSConfigurationStmt::tokentype() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterTSConfigurationStmt.tokentype)
  return _internal_tokentype();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterTSConfigurationStmt::_internal_tokentype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.tokentype_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterTSConfigurationStmt::_internal_mutable_tokentype() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.tokentype_;
}

// repeated .pg_query.Node dicts = 4 [json_name = "dicts"];
inline int AlterTSConfigurationStmt::_internal_dicts_size() const {
  return _internal_dicts().size();
}
inline int AlterTSConfigurationStmt::dicts_size() const {
  return _internal_dicts_size();
}
inline void AlterTSConfigurationStmt::clear_dicts() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.dicts_.Clear();
}
inline ::pg_query::Node* AlterTSConfigurationStmt::mutable_dicts(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterTSConfigurationStmt.dicts)
  return _internal_mutable_dicts()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterTSConfigurationStmt::mutable_dicts()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSConfigurationStmt.dicts)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_dicts();
}
inline const ::pg_query::Node& AlterTSConfigurationStmt::dicts(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.dicts)
  return _internal_dicts().Get(index);
}
inline ::pg_query::Node* AlterTSConfigurationStmt::add_dicts() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_dicts()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterTSConfigurationStmt.dicts)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterTSConfigurationStmt::dicts() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterTSConfigurationStmt.dicts)
  return _internal_dicts();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterTSConfigurationStmt::_internal_dicts() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.dicts_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterTSConfigurationStmt::_internal_mutable_dicts() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.dicts_;
}

// bool override = 5 [json_name = "override"];
inline void AlterTSConfigurationStmt::clear_override() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.override_ = false;
}
inline bool AlterTSConfigurationStmt::override() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.override)
  return _internal_override();
}
inline void AlterTSConfigurationStmt::set_override(bool value) {
  _internal_set_override(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTSConfigurationStmt.override)
}
inline bool AlterTSConfigurationStmt::_internal_override() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.override_;
}
inline void AlterTSConfigurationStmt::_internal_set_override(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.override_ = value;
}

// bool replace = 6 [json_name = "replace"];
inline void AlterTSConfigurationStmt::clear_replace() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.replace_ = false;
}
inline bool AlterTSConfigurationStmt::replace() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.replace)
  return _internal_replace();
}
inline void AlterTSConfigurationStmt::set_replace(bool value) {
  _internal_set_replace(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTSConfigurationStmt.replace)
}
inline bool AlterTSConfigurationStmt::_internal_replace() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.replace_;
}
inline void AlterTSConfigurationStmt::_internal_set_replace(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.replace_ = value;
}

// bool missing_ok = 7 [json_name = "missing_ok"];
inline void AlterTSConfigurationStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool AlterTSConfigurationStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.missing_ok)
  return _internal_missing_ok();
}
inline void AlterTSConfigurationStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterTSConfigurationStmt.missing_ok)
}
inline bool AlterTSConfigurationStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void AlterTSConfigurationStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// -------------------------------------------------------------------

// PublicationTable

// .pg_query.RangeVar relation = 1 [json_name = "relation"];
inline bool PublicationTable::has_relation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relation_ != nullptr);
  return value;
}
inline void PublicationTable::clear_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.relation_ != nullptr) _impl_.relation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::RangeVar& PublicationTable::_internal_relation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::RangeVar* p = _impl_.relation_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_);
}
inline const ::pg_query::RangeVar& PublicationTable::relation() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PublicationTable.relation)
  return _internal_relation();
}
inline void PublicationTable::unsafe_arena_set_allocated_relation(::pg_query::RangeVar* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.relation_);
  }
  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PublicationTable.relation)
}
inline ::pg_query::RangeVar* PublicationTable::release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* released = _impl_.relation_;
  _impl_.relation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::RangeVar* PublicationTable::unsafe_arena_release_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PublicationTable.relation)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::RangeVar* temp = _impl_.relation_;
  _impl_.relation_ = nullptr;
  return temp;
}
inline ::pg_query::RangeVar* PublicationTable::_internal_mutable_relation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.relation_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArena());
    _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(p);
  }
  return _impl_.relation_;
}
inline ::pg_query::RangeVar* PublicationTable::mutable_relation() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::RangeVar* _msg = _internal_mutable_relation();
  // @@protoc_insertion_point(field_mutable:pg_query.PublicationTable.relation)
  return _msg;
}
inline void PublicationTable::set_allocated_relation(::pg_query::RangeVar* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::RangeVar*>(_impl_.relation_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::RangeVar*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.relation_ = reinterpret_cast<::pg_query::RangeVar*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.PublicationTable.relation)
}

// .pg_query.Node where_clause = 2 [json_name = "whereClause"];
inline bool PublicationTable::has_where_clause() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.where_clause_ != nullptr);
  return value;
}
inline void PublicationTable::clear_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.where_clause_ != nullptr) _impl_.where_clause_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::pg_query::Node& PublicationTable::_internal_where_clause() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::Node* p = _impl_.where_clause_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::Node&>(::pg_query::_Node_default_instance_);
}
inline const ::pg_query::Node& PublicationTable::where_clause() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PublicationTable.where_clause)
  return _internal_where_clause();
}
inline void PublicationTable::unsafe_arena_set_allocated_where_clause(::pg_query::Node* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.where_clause_);
  }
  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PublicationTable.where_clause)
}
inline ::pg_query::Node* PublicationTable::release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* released = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::Node* PublicationTable::unsafe_arena_release_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PublicationTable.where_clause)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::pg_query::Node* temp = _impl_.where_clause_;
  _impl_.where_clause_ = nullptr;
  return temp;
}
inline ::pg_query::Node* PublicationTable::_internal_mutable_where_clause() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.where_clause_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::Node>(GetArena());
    _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(p);
  }
  return _impl_.where_clause_;
}
inline ::pg_query::Node* PublicationTable::mutable_where_clause() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::Node* _msg = _internal_mutable_where_clause();
  // @@protoc_insertion_point(field_mutable:pg_query.PublicationTable.where_clause)
  return _msg;
}
inline void PublicationTable::set_allocated_where_clause(::pg_query::Node* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::Node*>(_impl_.where_clause_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::Node*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.where_clause_ = reinterpret_cast<::pg_query::Node*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.PublicationTable.where_clause)
}

// repeated .pg_query.Node columns = 3 [json_name = "columns"];
inline int PublicationTable::_internal_columns_size() const {
  return _internal_columns().size();
}
inline int PublicationTable::columns_size() const {
  return _internal_columns_size();
}
inline void PublicationTable::clear_columns() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.columns_.Clear();
}
inline ::pg_query::Node* PublicationTable::mutable_columns(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.PublicationTable.columns)
  return _internal_mutable_columns()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* PublicationTable::mutable_columns()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.PublicationTable.columns)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_columns();
}
inline const ::pg_query::Node& PublicationTable::columns(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PublicationTable.columns)
  return _internal_columns().Get(index);
}
inline ::pg_query::Node* PublicationTable::add_columns() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_columns()->Add();
  // @@protoc_insertion_point(field_add:pg_query.PublicationTable.columns)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& PublicationTable::columns() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.PublicationTable.columns)
  return _internal_columns();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
PublicationTable::_internal_columns() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.columns_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
PublicationTable::_internal_mutable_columns() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.columns_;
}

// -------------------------------------------------------------------

// PublicationObjSpec

// .pg_query.PublicationObjSpecType pubobjtype = 1 [json_name = "pubobjtype"];
inline void PublicationObjSpec::clear_pubobjtype() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.pubobjtype_ = 0;
}
inline ::pg_query::PublicationObjSpecType PublicationObjSpec::pubobjtype() const {
  // @@protoc_insertion_point(field_get:pg_query.PublicationObjSpec.pubobjtype)
  return _internal_pubobjtype();
}
inline void PublicationObjSpec::set_pubobjtype(::pg_query::PublicationObjSpecType value) {
  _internal_set_pubobjtype(value);
  // @@protoc_insertion_point(field_set:pg_query.PublicationObjSpec.pubobjtype)
}
inline ::pg_query::PublicationObjSpecType PublicationObjSpec::_internal_pubobjtype() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::PublicationObjSpecType>(_impl_.pubobjtype_);
}
inline void PublicationObjSpec::_internal_set_pubobjtype(::pg_query::PublicationObjSpecType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.pubobjtype_ = value;
}

// string name = 2 [json_name = "name"];
inline void PublicationObjSpec::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& PublicationObjSpec::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PublicationObjSpec.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void PublicationObjSpec::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.PublicationObjSpec.name)
}
inline std::string* PublicationObjSpec::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:pg_query.PublicationObjSpec.name)
  return _s;
}
inline const std::string& PublicationObjSpec::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void PublicationObjSpec::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* PublicationObjSpec::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* PublicationObjSpec::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PublicationObjSpec.name)
  return _impl_.name_.Release();
}
inline void PublicationObjSpec::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.PublicationObjSpec.name)
}

// .pg_query.PublicationTable pubtable = 3 [json_name = "pubtable"];
inline bool PublicationObjSpec::has_pubtable() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pubtable_ != nullptr);
  return value;
}
inline void PublicationObjSpec::clear_pubtable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.pubtable_ != nullptr) _impl_.pubtable_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::pg_query::PublicationTable& PublicationObjSpec::_internal_pubtable() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::pg_query::PublicationTable* p = _impl_.pubtable_;
  return p != nullptr ? *p : reinterpret_cast<const ::pg_query::PublicationTable&>(::pg_query::_PublicationTable_default_instance_);
}
inline const ::pg_query::PublicationTable& PublicationObjSpec::pubtable() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.PublicationObjSpec.pubtable)
  return _internal_pubtable();
}
inline void PublicationObjSpec::unsafe_arena_set_allocated_pubtable(::pg_query::PublicationTable* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.pubtable_);
  }
  _impl_.pubtable_ = reinterpret_cast<::pg_query::PublicationTable*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PublicationObjSpec.pubtable)
}
inline ::pg_query::PublicationTable* PublicationObjSpec::release_pubtable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::PublicationTable* released = _impl_.pubtable_;
  _impl_.pubtable_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::pg_query::PublicationTable* PublicationObjSpec::unsafe_arena_release_pubtable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.PublicationObjSpec.pubtable)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::pg_query::PublicationTable* temp = _impl_.pubtable_;
  _impl_.pubtable_ = nullptr;
  return temp;
}
inline ::pg_query::PublicationTable* PublicationObjSpec::_internal_mutable_pubtable() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.pubtable_ == nullptr) {
    auto* p = CreateMaybeMessage<::pg_query::PublicationTable>(GetArena());
    _impl_.pubtable_ = reinterpret_cast<::pg_query::PublicationTable*>(p);
  }
  return _impl_.pubtable_;
}
inline ::pg_query::PublicationTable* PublicationObjSpec::mutable_pubtable() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::pg_query::PublicationTable* _msg = _internal_mutable_pubtable();
  // @@protoc_insertion_point(field_mutable:pg_query.PublicationObjSpec.pubtable)
  return _msg;
}
inline void PublicationObjSpec::set_allocated_pubtable(::pg_query::PublicationTable* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::pg_query::PublicationTable*>(_impl_.pubtable_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::pg_query::PublicationTable*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.pubtable_ = reinterpret_cast<::pg_query::PublicationTable*>(value);
  // @@protoc_insertion_point(field_set_allocated:pg_query.PublicationObjSpec.pubtable)
}

// int32 location = 4 [json_name = "location"];
inline void PublicationObjSpec::clear_location() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.location_ = 0;
}
inline ::int32_t PublicationObjSpec::location() const {
  // @@protoc_insertion_point(field_get:pg_query.PublicationObjSpec.location)
  return _internal_location();
}
inline void PublicationObjSpec::set_location(::int32_t value) {
  _internal_set_location(value);
  // @@protoc_insertion_point(field_set:pg_query.PublicationObjSpec.location)
}
inline ::int32_t PublicationObjSpec::_internal_location() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.location_;
}
inline void PublicationObjSpec::_internal_set_location(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.location_ = value;
}

// -------------------------------------------------------------------

// CreatePublicationStmt

// string pubname = 1 [json_name = "pubname"];
inline void CreatePublicationStmt::clear_pubname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.pubname_.ClearToEmpty();
}
inline const std::string& CreatePublicationStmt::pubname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatePublicationStmt.pubname)
  return _internal_pubname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreatePublicationStmt::set_pubname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.pubname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreatePublicationStmt.pubname)
}
inline std::string* CreatePublicationStmt::mutable_pubname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_pubname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePublicationStmt.pubname)
  return _s;
}
inline const std::string& CreatePublicationStmt::_internal_pubname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.pubname_.Get();
}
inline void CreatePublicationStmt::_internal_set_pubname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.pubname_.Set(value, GetArena());
}
inline std::string* CreatePublicationStmt::_internal_mutable_pubname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.pubname_.Mutable( GetArena());
}
inline std::string* CreatePublicationStmt::release_pubname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreatePublicationStmt.pubname)
  return _impl_.pubname_.Release();
}
inline void CreatePublicationStmt::set_allocated_pubname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.pubname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.pubname_.IsDefault()) {
          _impl_.pubname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int CreatePublicationStmt::options_size() const {
  return _internal_options_size();
}
inline void CreatePublicationStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreatePublicationStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePublicationStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreatePublicationStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePublicationStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreatePublicationStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatePublicationStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreatePublicationStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreatePublicationStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreatePublicationStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreatePublicationStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreatePublicationStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreatePublicationStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// repeated .pg_query.Node pubobjects = 3 [json_name = "pubobjects"];
inline int CreatePublicationStmt::_internal_pubobjects_size() const {
  return _internal_pubobjects().size();
}
inline int CreatePublicationStmt::pubobjects_size() const {
  return _internal_pubobjects_size();
}
inline void CreatePublicationStmt::clear_pubobjects() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.pubobjects_.Clear();
}
inline ::pg_query::Node* CreatePublicationStmt::mutable_pubobjects(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreatePublicationStmt.pubobjects)
  return _internal_mutable_pubobjects()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreatePublicationStmt::mutable_pubobjects()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePublicationStmt.pubobjects)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_pubobjects();
}
inline const ::pg_query::Node& CreatePublicationStmt::pubobjects(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreatePublicationStmt.pubobjects)
  return _internal_pubobjects().Get(index);
}
inline ::pg_query::Node* CreatePublicationStmt::add_pubobjects() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_pubobjects()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreatePublicationStmt.pubobjects)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreatePublicationStmt::pubobjects() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreatePublicationStmt.pubobjects)
  return _internal_pubobjects();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreatePublicationStmt::_internal_pubobjects() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.pubobjects_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreatePublicationStmt::_internal_mutable_pubobjects() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.pubobjects_;
}

// bool for_all_tables = 4 [json_name = "for_all_tables"];
inline void CreatePublicationStmt::clear_for_all_tables() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.for_all_tables_ = false;
}
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::set_for_all_tables(bool value) {
  _internal_set_for_all_tables(value);
  // @@protoc_insertion_point(field_set:pg_query.CreatePublicationStmt.for_all_tables)
}
inline bool CreatePublicationStmt::_internal_for_all_tables() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.for_all_tables_;
}
inline void CreatePublicationStmt::_internal_set_for_all_tables(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.for_all_tables_ = value;
}

// -------------------------------------------------------------------

// AlterPublicationStmt

// string pubname = 1 [json_name = "pubname"];
inline void AlterPublicationStmt::clear_pubname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.pubname_.ClearToEmpty();
}
inline const std::string& AlterPublicationStmt::pubname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.pubname)
  return _internal_pubname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterPublicationStmt::set_pubname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.pubname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterPublicationStmt.pubname)
}
inline std::string* AlterPublicationStmt::mutable_pubname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_pubname();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPublicationStmt.pubname)
  return _s;
}
inline const std::string& AlterPublicationStmt::_internal_pubname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.pubname_.Get();
}
inline void AlterPublicationStmt::_internal_set_pubname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.pubname_.Set(value, GetArena());
}
inline std::string* AlterPublicationStmt::_internal_mutable_pubname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.pubname_.Mutable( GetArena());
}
inline std::string* AlterPublicationStmt::release_pubname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterPublicationStmt.pubname)
  return _impl_.pubname_.Release();
}
inline void AlterPublicationStmt::set_allocated_pubname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.pubname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.pubname_.IsDefault()) {
          _impl_.pubname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_options().size();
}
inline int AlterPublicationStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterPublicationStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterPublicationStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPublicationStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterPublicationStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterPublicationStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterPublicationStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterPublicationStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterPublicationStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterPublicationStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterPublicationStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterPublicationStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterPublicationStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// repeated .pg_query.Node pubobjects = 3 [json_name = "pubobjects"];
inline int AlterPublicationStmt::_internal_pubobjects_size() const {
  return _internal_pubobjects().size();
}
inline int AlterPublicationStmt::pubobjects_size() const {
  return _internal_pubobjects_size();
}
inline void AlterPublicationStmt::clear_pubobjects() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.pubobjects_.Clear();
}
inline ::pg_query::Node* AlterPublicationStmt::mutable_pubobjects(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterPublicationStmt.pubobjects)
  return _internal_mutable_pubobjects()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterPublicationStmt::mutable_pubobjects()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterPublicationStmt.pubobjects)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_pubobjects();
}
inline const ::pg_query::Node& AlterPublicationStmt::pubobjects(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.pubobjects)
  return _internal_pubobjects().Get(index);
}
inline ::pg_query::Node* AlterPublicationStmt::add_pubobjects() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_pubobjects()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterPublicationStmt.pubobjects)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterPublicationStmt::pubobjects() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterPublicationStmt.pubobjects)
  return _internal_pubobjects();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterPublicationStmt::_internal_pubobjects() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.pubobjects_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterPublicationStmt::_internal_mutable_pubobjects() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.pubobjects_;
}

// bool for_all_tables = 4 [json_name = "for_all_tables"];
inline void AlterPublicationStmt::clear_for_all_tables() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.for_all_tables_ = false;
}
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::set_for_all_tables(bool value) {
  _internal_set_for_all_tables(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterPublicationStmt.for_all_tables)
}
inline bool AlterPublicationStmt::_internal_for_all_tables() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.for_all_tables_;
}
inline void AlterPublicationStmt::_internal_set_for_all_tables(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.for_all_tables_ = value;
}

// .pg_query.AlterPublicationAction action = 5 [json_name = "action"];
inline void AlterPublicationStmt::clear_action() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.action_ = 0;
}
inline ::pg_query::AlterPublicationAction AlterPublicationStmt::action() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.action)
  return _internal_action();
}
inline void AlterPublicationStmt::set_action(::pg_query::AlterPublicationAction value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterPublicationStmt.action)
}
inline ::pg_query::AlterPublicationAction AlterPublicationStmt::_internal_action() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::AlterPublicationAction>(_impl_.action_);
}
inline void AlterPublicationStmt::_internal_set_action(::pg_query::AlterPublicationAction value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.action_ = value;
}

// -------------------------------------------------------------------

// CreateSubscriptionStmt

// string subname = 1 [json_name = "subname"];
inline void CreateSubscriptionStmt::clear_subname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subname_.ClearToEmpty();
}
inline const std::string& CreateSubscriptionStmt::subname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateSubscriptionStmt.subname)
  return _internal_subname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateSubscriptionStmt::set_subname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.subname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateSubscriptionStmt.subname)
}
inline std::string* CreateSubscriptionStmt::mutable_subname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_subname();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSubscriptionStmt.subname)
  return _s;
}
inline const std::string& CreateSubscriptionStmt::_internal_subname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.subname_.Get();
}
inline void CreateSubscriptionStmt::_internal_set_subname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.subname_.Set(value, GetArena());
}
inline std::string* CreateSubscriptionStmt::_internal_mutable_subname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.subname_.Mutable( GetArena());
}
inline std::string* CreateSubscriptionStmt::release_subname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateSubscriptionStmt.subname)
  return _impl_.subname_.Release();
}
inline void CreateSubscriptionStmt::set_allocated_subname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.subname_.IsDefault()) {
          _impl_.subname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.CreateSubscriptionStmt.subname)
}

// string conninfo = 2 [json_name = "conninfo"];
inline void CreateSubscriptionStmt::clear_conninfo() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conninfo_.ClearToEmpty();
}
inline const std::string& CreateSubscriptionStmt::conninfo() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateSubscriptionStmt.conninfo)
  return _internal_conninfo();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CreateSubscriptionStmt::set_conninfo(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conninfo_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.CreateSubscriptionStmt.conninfo)
}
inline std::string* CreateSubscriptionStmt::mutable_conninfo() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_conninfo();
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSubscriptionStmt.conninfo)
  return _s;
}
inline const std::string& CreateSubscriptionStmt::_internal_conninfo() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.conninfo_.Get();
}
inline void CreateSubscriptionStmt::_internal_set_conninfo(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conninfo_.Set(value, GetArena());
}
inline std::string* CreateSubscriptionStmt::_internal_mutable_conninfo() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.conninfo_.Mutable( GetArena());
}
inline std::string* CreateSubscriptionStmt::release_conninfo() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.CreateSubscriptionStmt.conninfo)
  return _impl_.conninfo_.Release();
}
inline void CreateSubscriptionStmt::set_allocated_conninfo(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conninfo_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.conninfo_.IsDefault()) {
          _impl_.conninfo_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_publication().size();
}
inline int CreateSubscriptionStmt::publication_size() const {
  return _internal_publication_size();
}
inline void CreateSubscriptionStmt::clear_publication() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.publication_.Clear();
}
inline ::pg_query::Node* CreateSubscriptionStmt::mutable_publication(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSubscriptionStmt.publication)
  return _internal_mutable_publication()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateSubscriptionStmt::mutable_publication()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateSubscriptionStmt.publication)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_publication();
}
inline const ::pg_query::Node& CreateSubscriptionStmt::publication(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateSubscriptionStmt.publication)
  return _internal_publication().Get(index);
}
inline ::pg_query::Node* CreateSubscriptionStmt::add_publication() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_publication()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateSubscriptionStmt.publication)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateSubscriptionStmt::publication() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateSubscriptionStmt.publication)
  return _internal_publication();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateSubscriptionStmt::_internal_publication() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.publication_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateSubscriptionStmt::_internal_mutable_publication() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.publication_;
}

// repeated .pg_query.Node options = 4 [json_name = "options"];
inline int CreateSubscriptionStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int CreateSubscriptionStmt::options_size() const {
  return _internal_options_size();
}
inline void CreateSubscriptionStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* CreateSubscriptionStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.CreateSubscriptionStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* CreateSubscriptionStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.CreateSubscriptionStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& CreateSubscriptionStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.CreateSubscriptionStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* CreateSubscriptionStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.CreateSubscriptionStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& CreateSubscriptionStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.CreateSubscriptionStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
CreateSubscriptionStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
CreateSubscriptionStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// AlterSubscriptionStmt

// .pg_query.AlterSubscriptionType kind = 1 [json_name = "kind"];
inline void AlterSubscriptionStmt::clear_kind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.kind_ = 0;
}
inline ::pg_query::AlterSubscriptionType AlterSubscriptionStmt::kind() const {
  // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.kind)
  return _internal_kind();
}
inline void AlterSubscriptionStmt::set_kind(::pg_query::AlterSubscriptionType value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.AlterSubscriptionStmt.kind)
}
inline ::pg_query::AlterSubscriptionType AlterSubscriptionStmt::_internal_kind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::AlterSubscriptionType>(_impl_.kind_);
}
inline void AlterSubscriptionStmt::_internal_set_kind(::pg_query::AlterSubscriptionType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.kind_ = value;
}

// string subname = 2 [json_name = "subname"];
inline void AlterSubscriptionStmt::clear_subname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subname_.ClearToEmpty();
}
inline const std::string& AlterSubscriptionStmt::subname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.subname)
  return _internal_subname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterSubscriptionStmt::set_subname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.subname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterSubscriptionStmt.subname)
}
inline std::string* AlterSubscriptionStmt::mutable_subname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_subname();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSubscriptionStmt.subname)
  return _s;
}
inline const std::string& AlterSubscriptionStmt::_internal_subname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.subname_.Get();
}
inline void AlterSubscriptionStmt::_internal_set_subname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.subname_.Set(value, GetArena());
}
inline std::string* AlterSubscriptionStmt::_internal_mutable_subname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.subname_.Mutable( GetArena());
}
inline std::string* AlterSubscriptionStmt::release_subname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterSubscriptionStmt.subname)
  return _impl_.subname_.Release();
}
inline void AlterSubscriptionStmt::set_allocated_subname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.subname_.IsDefault()) {
          _impl_.subname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.AlterSubscriptionStmt.subname)
}

// string conninfo = 3 [json_name = "conninfo"];
inline void AlterSubscriptionStmt::clear_conninfo() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conninfo_.ClearToEmpty();
}
inline const std::string& AlterSubscriptionStmt::conninfo() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.conninfo)
  return _internal_conninfo();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AlterSubscriptionStmt::set_conninfo(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conninfo_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.AlterSubscriptionStmt.conninfo)
}
inline std::string* AlterSubscriptionStmt::mutable_conninfo() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_conninfo();
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSubscriptionStmt.conninfo)
  return _s;
}
inline const std::string& AlterSubscriptionStmt::_internal_conninfo() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.conninfo_.Get();
}
inline void AlterSubscriptionStmt::_internal_set_conninfo(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.conninfo_.Set(value, GetArena());
}
inline std::string* AlterSubscriptionStmt::_internal_mutable_conninfo() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.conninfo_.Mutable( GetArena());
}
inline std::string* AlterSubscriptionStmt::release_conninfo() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.AlterSubscriptionStmt.conninfo)
  return _impl_.conninfo_.Release();
}
inline void AlterSubscriptionStmt::set_allocated_conninfo(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.conninfo_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.conninfo_.IsDefault()) {
          _impl_.conninfo_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@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 _internal_publication().size();
}
inline int AlterSubscriptionStmt::publication_size() const {
  return _internal_publication_size();
}
inline void AlterSubscriptionStmt::clear_publication() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.publication_.Clear();
}
inline ::pg_query::Node* AlterSubscriptionStmt::mutable_publication(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSubscriptionStmt.publication)
  return _internal_mutable_publication()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterSubscriptionStmt::mutable_publication()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterSubscriptionStmt.publication)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_publication();
}
inline const ::pg_query::Node& AlterSubscriptionStmt::publication(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.publication)
  return _internal_publication().Get(index);
}
inline ::pg_query::Node* AlterSubscriptionStmt::add_publication() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_publication()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterSubscriptionStmt.publication)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterSubscriptionStmt::publication() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterSubscriptionStmt.publication)
  return _internal_publication();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterSubscriptionStmt::_internal_publication() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.publication_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterSubscriptionStmt::_internal_mutable_publication() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.publication_;
}

// repeated .pg_query.Node options = 5 [json_name = "options"];
inline int AlterSubscriptionStmt::_internal_options_size() const {
  return _internal_options().size();
}
inline int AlterSubscriptionStmt::options_size() const {
  return _internal_options_size();
}
inline void AlterSubscriptionStmt::clear_options() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.options_.Clear();
}
inline ::pg_query::Node* AlterSubscriptionStmt::mutable_options(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:pg_query.AlterSubscriptionStmt.options)
  return _internal_mutable_options()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>* AlterSubscriptionStmt::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:pg_query.AlterSubscriptionStmt.options)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_options();
}
inline const ::pg_query::Node& AlterSubscriptionStmt::options(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.options)
  return _internal_options().Get(index);
}
inline ::pg_query::Node* AlterSubscriptionStmt::add_options() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::pg_query::Node* _add = _internal_mutable_options()->Add();
  // @@protoc_insertion_point(field_add:pg_query.AlterSubscriptionStmt.options)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>& AlterSubscriptionStmt::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:pg_query.AlterSubscriptionStmt.options)
  return _internal_options();
}
inline const ::google::protobuf::RepeatedPtrField<::pg_query::Node>&
AlterSubscriptionStmt::_internal_options() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.options_;
}
inline ::google::protobuf::RepeatedPtrField<::pg_query::Node>*
AlterSubscriptionStmt::_internal_mutable_options() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.options_;
}

// -------------------------------------------------------------------

// DropSubscriptionStmt

// string subname = 1 [json_name = "subname"];
inline void DropSubscriptionStmt::clear_subname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subname_.ClearToEmpty();
}
inline const std::string& DropSubscriptionStmt::subname() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:pg_query.DropSubscriptionStmt.subname)
  return _internal_subname();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DropSubscriptionStmt::set_subname(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.subname_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:pg_query.DropSubscriptionStmt.subname)
}
inline std::string* DropSubscriptionStmt::mutable_subname() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_subname();
  // @@protoc_insertion_point(field_mutable:pg_query.DropSubscriptionStmt.subname)
  return _s;
}
inline const std::string& DropSubscriptionStmt::_internal_subname() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.subname_.Get();
}
inline void DropSubscriptionStmt::_internal_set_subname(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.subname_.Set(value, GetArena());
}
inline std::string* DropSubscriptionStmt::_internal_mutable_subname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.subname_.Mutable( GetArena());
}
inline std::string* DropSubscriptionStmt::release_subname() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:pg_query.DropSubscriptionStmt.subname)
  return _impl_.subname_.Release();
}
inline void DropSubscriptionStmt::set_allocated_subname(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subname_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.subname_.IsDefault()) {
          _impl_.subname_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:pg_query.DropSubscriptionStmt.subname)
}

// bool missing_ok = 2 [json_name = "missing_ok"];
inline void DropSubscriptionStmt::clear_missing_ok() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.missing_ok_ = false;
}
inline bool DropSubscriptionStmt::missing_ok() const {
  // @@protoc_insertion_point(field_get:pg_query.DropSubscriptionStmt.missing_ok)
  return _internal_missing_ok();
}
inline void DropSubscriptionStmt::set_missing_ok(bool value) {
  _internal_set_missing_ok(value);
  // @@protoc_insertion_point(field_set:pg_query.DropSubscriptionStmt.missing_ok)
}
inline bool DropSubscriptionStmt::_internal_missing_ok() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.missing_ok_;
}
inline void DropSubscriptionStmt::_internal_set_missing_ok(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.missing_ok_ = value;
}

// .pg_query.DropBehavior behavior = 3 [json_name = "behavior"];
inline void DropSubscriptionStmt::clear_behavior() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.behavior_ = 0;
}
inline ::pg_query::DropBehavior DropSubscriptionStmt::behavior() const {
  // @@protoc_insertion_point(field_get:pg_query.DropSubscriptionStmt.behavior)
  return _internal_behavior();
}
inline void DropSubscriptionStmt::set_behavior(::pg_query::DropBehavior value) {
  _internal_set_behavior(value);
  // @@protoc_insertion_point(field_set:pg_query.DropSubscriptionStmt.behavior)
}
inline ::pg_query::DropBehavior DropSubscriptionStmt::_internal_behavior() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::DropBehavior>(_impl_.behavior_);
}
inline void DropSubscriptionStmt::_internal_set_behavior(::pg_query::DropBehavior value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.behavior_ = value;
}

// -------------------------------------------------------------------

// ScanToken

// int32 start = 1;
inline void ScanToken::clear_start() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.start_ = 0;
}
inline ::int32_t ScanToken::start() const {
  // @@protoc_insertion_point(field_get:pg_query.ScanToken.start)
  return _internal_start();
}
inline void ScanToken::set_start(::int32_t value) {
  _internal_set_start(value);
  // @@protoc_insertion_point(field_set:pg_query.ScanToken.start)
}
inline ::int32_t ScanToken::_internal_start() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.start_;
}
inline void ScanToken::_internal_set_start(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.start_ = value;
}

// int32 end = 2;
inline void ScanToken::clear_end() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.end_ = 0;
}
inline ::int32_t ScanToken::end() const {
  // @@protoc_insertion_point(field_get:pg_query.ScanToken.end)
  return _internal_end();
}
inline void ScanToken::set_end(::int32_t value) {
  _internal_set_end(value);
  // @@protoc_insertion_point(field_set:pg_query.ScanToken.end)
}
inline ::int32_t ScanToken::_internal_end() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.end_;
}
inline void ScanToken::_internal_set_end(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.end_ = value;
}

// .pg_query.Token token = 4;
inline void ScanToken::clear_token() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.token_ = 0;
}
inline ::pg_query::Token ScanToken::token() const {
  // @@protoc_insertion_point(field_get:pg_query.ScanToken.token)
  return _internal_token();
}
inline void ScanToken::set_token(::pg_query::Token value) {
  _internal_set_token(value);
  // @@protoc_insertion_point(field_set:pg_query.ScanToken.token)
}
inline ::pg_query::Token ScanToken::_internal_token() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::Token>(_impl_.token_);
}
inline void ScanToken::_internal_set_token(::pg_query::Token value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.token_ = value;
}

// .pg_query.KeywordKind keyword_kind = 5;
inline void ScanToken::clear_keyword_kind() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.keyword_kind_ = 0;
}
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::set_keyword_kind(::pg_query::KeywordKind value) {
  _internal_set_keyword_kind(value);
  // @@protoc_insertion_point(field_set:pg_query.ScanToken.keyword_kind)
}
inline ::pg_query::KeywordKind ScanToken::_internal_keyword_kind() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::pg_query::KeywordKind>(_impl_.keyword_kind_);
}
inline void ScanToken::_internal_set_keyword_kind(::pg_query::KeywordKind value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.keyword_kind_ = value;
}

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace pg_query


namespace google {
namespace protobuf {

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::SetQuantifier> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::pg_query::SetQuantifier>() {
  return ::pg_query::SetQuantifier_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::PartitionStrategy> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::pg_query::PartitionStrategy>() {
  return ::pg_query::PartitionStrategy_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::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::PublicationObjSpecType> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::pg_query::PublicationObjSpecType>() {
  return ::pg_query::PublicationObjSpecType_descriptor();
}
template <>
struct is_proto_enum<::pg_query::AlterPublicationAction> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::pg_query::AlterPublicationAction>() {
  return ::pg_query::AlterPublicationAction_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::JsonEncoding> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::pg_query::JsonEncoding>() {
  return ::pg_query::JsonEncoding_descriptor();
}
template <>
struct is_proto_enum<::pg_query::JsonFormatType> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::pg_query::JsonFormatType>() {
  return ::pg_query::JsonFormatType_descriptor();
}
template <>
struct is_proto_enum<::pg_query::JsonConstructorType> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::pg_query::JsonConstructorType>() {
  return ::pg_query::JsonConstructorType_descriptor();
}
template <>
struct is_proto_enum<::pg_query::JsonValueType> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::pg_query::JsonValueType>() {
  return ::pg_query::JsonValueType_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();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_protobuf_2fpg_5fquery_2eproto_2epb_2eh